@react-shimeji/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1362 @@
+// src/dom.ts
+var DomManager = class {
+  /** Creates an isolated work area inside the supplied host element. */
+  constructor(container, sprites, workAreaClassName) {
+    this.container = container;
+    this.sprites = sprites;
+    const workArea = document.createElement("div");
+    workArea.dataset.reactShimejiWorkArea = "true";
+    if (workAreaClassName) workArea.className = workAreaClassName;
+    Object.assign(workArea.style, {
+      position: "absolute",
+      inset: "0",
+      width: "100%",
+      height: "100%",
+      overflow: "hidden",
+      pointerEvents: "none",
+      zIndex: "2147483643"
+    });
+    this.workArea = workArea;
+    this.ensureMounted();
+  }
+  container;
+  sprites;
+  /** Generated element that contains all mascots. */
+  workArea;
+  /** Reattaches the work area if application code temporarily removed it. */
+  ensureMounted() {
+    if (this.workArea.parentElement !== this.container) this.container.appendChild(this.workArea);
+  }
+  /** Returns the current local work-area rectangle. */
+  getBounds() {
+    const rectangle = this.workArea.getBoundingClientRect();
+    const width = rectangle.width || this.container.clientWidth || window.innerWidth;
+    const height = rectangle.height || this.container.clientHeight || window.innerHeight;
+    return { x: 0, y: 0, width, height };
+  }
+  /** Creates a mascot node and acquires its spritesheet resource. */
+  createMascot(spec, mascotId, mascotClassName) {
+    const spriteLease = this.sprites.acquire(spec.spritesheet);
+    const element = document.createElement("div");
+    element.dataset.shimejiId = mascotId;
+    if (mascotClassName) element.className = mascotClassName;
+    Object.assign(element.style, { position: "absolute", left: "0", top: "0", width: "0", height: "0", pointerEvents: "auto", touchAction: "none", userSelect: "none", willChange: "transform" });
+    const spriteElement = document.createElement("div");
+    Object.assign(spriteElement.style, { position: "absolute", left: "0", top: "0", backgroundRepeat: "no-repeat", transformOrigin: "center center", pointerEvents: "none" });
+    element.appendChild(spriteElement);
+    this.workArea.appendChild(element);
+    return { element, spriteElement, spriteLease };
+  }
+  /** Paints one mascot state into its existing DOM nodes. */
+  render(handle, spec, state) {
+    const sprite = this.sprites.resolve(spec, handle.spriteLease, state.sprite);
+    handle.element.style.transform = `translate3d(${state.x - state.anchorX}px, ${state.y - state.anchorY}px, 0)`;
+    handle.spriteElement.style.left = "0";
+    handle.spriteElement.style.top = "0";
+    handle.spriteElement.style.transform = `scaleX(${state.lookRight ? -1 : 1})`;
+    if (!sprite) return;
+    handle.spriteElement.style.backgroundImage = `url("${sprite.url.replaceAll('"', '\\"')}")`;
+    if (sprite.rectangle) {
+      handle.spriteElement.style.width = `${sprite.rectangle.width}px`;
+      handle.spriteElement.style.height = `${sprite.rectangle.height}px`;
+      handle.element.style.width = `${sprite.rectangle.width}px`;
+      handle.element.style.height = `${sprite.rectangle.height}px`;
+      handle.spriteElement.style.backgroundPosition = `${-sprite.rectangle.x}px ${-sprite.rectangle.y}px`;
+      handle.spriteElement.style.backgroundSize = "auto";
+    } else {
+      handle.spriteElement.style.backgroundPosition = "0 0";
+      handle.spriteElement.style.backgroundSize = "contain";
+      handle.spriteElement.style.width = "128px";
+      handle.spriteElement.style.height = "128px";
+      const definition = Object.values(spec.sprites).find((candidate) => typeof candidate === "object" && "url" in candidate && candidate.url === sprite.url);
+      if (typeof definition === "object" && "width" in definition && definition.width !== void 0) handle.spriteElement.style.width = `${definition.width}px`;
+      if (typeof definition === "object" && "height" in definition && definition.height !== void 0) handle.spriteElement.style.height = `${definition.height}px`;
+      handle.element.style.width = handle.spriteElement.style.width;
+      handle.element.style.height = handle.spriteElement.style.height;
+    }
+  }
+  /** Removes one mascot node and releases its temporary image URL. */
+  removeMascot(handle) {
+    handle.element.remove();
+    handle.spriteLease.release();
+  }
+  /** Removes the work area owned by this manager. */
+  destroy() {
+    this.workArea.remove();
+  }
+};
+
+// src/loader.ts
+var actionTypeNames = {
+  Sequence: "Sequence",
+  Select: "Select",
+  Reference: "Reference",
+  Stay: "Stay",
+  Animate: "Animate",
+  Move: "Move",
+  Embedded: "Embedded",
+  \u8907\u5408: "Sequence",
+  \u9078\u629E: "Select",
+  \u53C2\u7167: "Reference",
+  \u9759\u6B62: "Stay",
+  \u56FA\u5B9A: "Animate",
+  \u79FB\u52D5: "Move",
+  \u7D44\u307F\u8FBC\u307F: "Embedded"
+};
+var borderTypeNames = { Floor: "Floor", Wall: "Wall", Ceiling: "Ceiling", \u5730\u9762: "Floor", \u58C1: "Wall", \u5929\u4E95: "Ceiling" };
+function parseJson(value, label) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new TypeError(`Invalid ${label}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function attribute(element, ...names) {
+  for (const name of names) {
+    const value = element.getAttribute(name);
+    if (value !== null) return value;
+  }
+  return void 0;
+}
+function directChildren(element, ...names) {
+  const accepted = new Set(names);
+  return Array.from(element.children).filter((child) => accepted.has(child.localName) || accepted.has(child.tagName));
+}
+function parsePoint(value, fallback = { x: 0, y: 0 }) {
+  if (!value) return fallback;
+  const [x = fallback.x, y = fallback.y] = value.split(",").map(Number);
+  return { x: Number.isFinite(x) ? x : fallback.x, y: Number.isFinite(y) ? y : fallback.y };
+}
+function requireDomParser() {
+  if (typeof DOMParser === "undefined") throw new Error("XML character packs require the browser DOMParser API; use pre-parsed JSON in non-browser environments");
+  return new DOMParser();
+}
+function parseDocument(xml, label) {
+  const document2 = requireDomParser().parseFromString(xml.replace(/^\uFEFF/, ""), "application/xml");
+  const error = document2.querySelector("parsererror");
+  if (error) throw new TypeError(`Invalid ${label}: ${error.textContent?.trim() ?? "XML parse error"}`);
+  return document2;
+}
+function actionProperty(element, ...names) {
+  return attribute(element, ...names);
+}
+function parseAnimation(element) {
+  const poses = directChildren(element, "Pose", "\u30DD\u30FC\u30BA").map((pose) => ({
+    sprite: attribute(pose, "Image", "\u753B\u50CF") ?? "/shime1.png",
+    anchor: parsePoint(attribute(pose, "Anchor", "\u57FA\u6E96\u5EA7\u6A19"), { x: 64, y: 128 }),
+    velocity: parsePoint(attribute(pose, "Velocity", "\u79FB\u52D5\u901F\u5EA6")),
+    duration: Number(attribute(pose, "Duration", "\u9577\u3055") ?? 1)
+  }));
+  const condition = attribute(element, "Condition", "\u6761\u4EF6");
+  return { poses, ...condition !== void 0 && { condition } };
+}
+function parseActionElement(element) {
+  const isReference = element.localName === "ActionReference" || element.localName === "\u52D5\u4F5C\u53C2\u7167";
+  const rawType = isReference ? "Reference" : attribute(element, "Type", "\u7A2E\u985E") ?? (directChildren(element, "Action", "\u52D5\u4F5C", "ActionReference", "\u52D5\u4F5C\u53C2\u7167").length ? "Sequence" : "Animate");
+  const className = attribute(element, "Class", "\u30AF\u30E9\u30B9");
+  const embedType = className?.split(".").at(-1);
+  const type = actionTypeNames[rawType] ?? (embedType ? "Embedded" : "Animate");
+  const name = attribute(element, "Name", "\u540D\u524D");
+  const condition = actionProperty(element, "Condition", "\u6761\u4EF6");
+  const borderRaw = actionProperty(element, "BorderType", "Border", "\u67A0");
+  const actions = directChildren(element, "Action", "\u52D5\u4F5C", "ActionReference", "\u52D5\u4F5C\u53C2\u7167").map(parseActionElement);
+  const animations = directChildren(element, "Animation", "\u30A2\u30CB\u30E1\u30FC\u30B7\u30E7\u30F3").map(parseAnimation);
+  const result = {
+    type,
+    ...name !== void 0 && { name },
+    ...embedType !== void 0 && { embedType },
+    ...condition !== void 0 && { condition },
+    ...borderRaw !== void 0 && borderTypeNames[borderRaw] !== void 0 && { borderType: borderTypeNames[borderRaw] },
+    ...actions.length > 0 && { actions },
+    ...animations.length > 0 && { animations }
+  };
+  const properties = [
+    ["duration", actionProperty(element, "Duration", "\u9577\u3055")],
+    ["gap", actionProperty(element, "Gap", "\u9593\u9694")],
+    ["targetX", actionProperty(element, "TargetX", "\u76EE\u7684\u5730X")],
+    ["targetY", actionProperty(element, "TargetY", "\u76EE\u7684\u5730Y")],
+    ["velocity", actionProperty(element, "Velocity", "\u901F\u5EA6")],
+    ["x", actionProperty(element, "X", "\u5909\u4F4DX")],
+    ["y", actionProperty(element, "Y", "\u5909\u4F4DY")],
+    ["initialVx", actionProperty(element, "InitialVX", "InitialVx", "\u521D\u901FX")],
+    ["initialVy", actionProperty(element, "InitialVY", "InitialVy", "\u521D\u901FY")],
+    ["resistanceX", actionProperty(element, "ResistanceX", "\u7A7A\u6C17\u62B5\u6297X")],
+    ["resistanceY", actionProperty(element, "ResistanceY", "\u7A7A\u6C17\u62B5\u6297Y")],
+    ["gravity", actionProperty(element, "Gravity", "\u91CD\u529B")],
+    ["bornX", actionProperty(element, "BornX", "\u8A95\u751FX")],
+    ["bornY", actionProperty(element, "BornY", "\u8A95\u751FY")],
+    ["bornBehavior", actionProperty(element, "BornBehavior", "\u8A95\u751F\u6642\u306E\u884C\u52D5")],
+    ["ieOffsetX", actionProperty(element, "IEOffsetX", "IE\u306E\u7AEFX")],
+    ["ieOffsetY", actionProperty(element, "IEOffsetY", "IE\u306E\u7AEFY")],
+    ["lookRight", actionProperty(element, "LookRight", "\u53F3\u5411\u304D")]
+  ];
+  for (const [key, value] of properties) if (value !== void 0) result[key] = value;
+  const loop = actionProperty(element, "Loop", "\u7E70\u308A\u8FD4\u3057");
+  if (loop !== void 0) result.loop = loop.toLowerCase() === "true";
+  return result;
+}
+function parseActionsXml(xml) {
+  const document2 = parseDocument(xml, "actions.xml");
+  const lists = Array.from(document2.getElementsByTagNameNS("*", "ActionList")).concat(Array.from(document2.getElementsByTagNameNS("*", "\u52D5\u4F5C\u30EA\u30B9\u30C8")));
+  const roots = lists.length ? lists : [document2.documentElement];
+  return roots.flatMap((list) => directChildren(list, "Action", "\u52D5\u4F5C").map(parseActionElement));
+}
+function parseBehaviorElement(element, inheritedConditions, groupIndex) {
+  const condition = attribute(element, "Condition", "\u6761\u4EF6");
+  const conditions = [...inheritedConditions, ...condition ? [condition] : []];
+  const nextList = directChildren(element, "NextBehaviorList", "NextBehavior", "\u6B21\u306E\u884C\u52D5\u30EA\u30B9\u30C8")[0];
+  const nextBehaviors = nextList ? directChildren(nextList, "Behavior", "\u884C\u52D5", "BehaviorReference", "BehaviorReferance", "\u884C\u52D5\u53C2\u7167").map((child) => parseBehaviorElement(child, conditions, 0)) : [];
+  const reference = element.localName === "BehaviorReference" || element.localName === "BehaviorReferance" || element.localName === "\u884C\u52D5\u53C2\u7167";
+  return {
+    type: reference ? "Reference" : "Behavior",
+    name: attribute(element, "Name", "\u540D\u524D") ?? "",
+    frequency: Number(attribute(element, "Frequency", "\u983B\u5EA6") ?? 0),
+    conditions,
+    nextBehaviors,
+    groupIndex,
+    hidden: (attribute(element, "Hidden", "\u975E\u8868\u793A") ?? "false").toLowerCase() === "true"
+  };
+}
+function parseBehaviorsXml(xml) {
+  const document2 = parseDocument(xml, "behaviors.xml");
+  const lists = Array.from(document2.getElementsByTagNameNS("*", "BehaviorList")).concat(Array.from(document2.getElementsByTagNameNS("*", "\u884C\u52D5\u30EA\u30B9\u30C8")));
+  const root = lists[0] ?? document2.documentElement;
+  const behaviors = [];
+  let groupIndex = 0;
+  for (const child of Array.from(root.children)) {
+    if (child.localName === "Condition" || child.localName === "\u6761\u4EF6") {
+      groupIndex += 1;
+      const condition = attribute(child, "Condition", "\u6761\u4EF6");
+      const inherited = condition ? [condition] : [];
+      behaviors.push(...directChildren(child, "Behavior", "\u884C\u52D5", "BehaviorReference", "BehaviorReferance", "\u884C\u52D5\u53C2\u7167").map((element) => parseBehaviorElement(element, inherited, groupIndex)));
+    } else if (["Behavior", "\u884C\u52D5", "BehaviorReference", "BehaviorReferance", "\u884C\u52D5\u53C2\u7167"].includes(child.localName)) {
+      behaviors.push(parseBehaviorElement(child, [], 0));
+    }
+  }
+  return behaviors;
+}
+function isCharacterSpec(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.id === "string" && Array.isArray(candidate.actions) && Array.isArray(candidate.behaviors) && typeof candidate.sprites === "object" && candidate.sprites !== null && (typeof candidate.spritesheet === "string" || typeof Blob !== "undefined" && candidate.spritesheet instanceof Blob);
+}
+function normalizeCharacterSpec(input) {
+  let candidate = input;
+  if (typeof candidate === "string") candidate = parseJson(candidate, "character JSON");
+  if (!candidate || typeof candidate !== "object") throw new TypeError("Character data must be an object");
+  const record = candidate;
+  if (record.configuration) {
+    const configuration = typeof record.configuration === "string" ? parseJson(record.configuration, "configuration") : record.configuration;
+    if (typeof configuration === "object") candidate = { ...configuration, ...record };
+  }
+  const pack = candidate;
+  const id = typeof pack.id === "string" ? pack.id : typeof pack.metadata?.shimeji === "string" ? pack.metadata.shimeji : void 0;
+  if (!id) throw new TypeError("Character specification requires an id");
+  if (pack.actions === void 0 || pack.behaviors === void 0 || pack.sprites === void 0 || pack.spritesheet === void 0) throw new TypeError(`Character '${id}' is missing actions, behaviors, sprites, or spritesheet`);
+  const actions = typeof pack.actions === "string" && pack.actions.trimStart().startsWith("<") ? parseActionsXml(pack.actions) : parseJson(pack.actions, "actions");
+  const behaviors = typeof pack.behaviors === "string" && pack.behaviors.trimStart().startsWith("<") ? parseBehaviorsXml(pack.behaviors) : parseJson(pack.behaviors, "behaviors");
+  const sprites = parseJson(pack.sprites, "sprites");
+  const spec = {
+    id,
+    spritesheet: pack.spritesheet,
+    sprites,
+    actions,
+    behaviors,
+    ...typeof pack.name === "string" && { name: pack.name },
+    ...pack.metadata !== void 0 && { metadata: pack.metadata }
+  };
+  if (!isCharacterSpec(spec)) throw new TypeError(`Character '${id}' could not be normalized`);
+  return spec;
+}
+async function loadCharacter(source) {
+  if (typeof source !== "string" && !(source instanceof URL)) return normalizeCharacterSpec(source);
+  const url = source instanceof URL ? source : new URL(source, typeof document === "undefined" ? "http://localhost/" : document.baseURI);
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Unable to load character '${url}': ${response.status} ${response.statusText}`);
+  const spec = normalizeCharacterSpec(await response.json());
+  if (typeof spec.spritesheet === "string" && !/^(?:data:|blob:)/.test(spec.spritesheet)) {
+    spec.spritesheet = new URL(spec.spritesheet, url).toString();
+  }
+  return spec;
+}
+
+// src/behavior.ts
+var forbiddenProperties = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var functions = {
+  abs: Math.abs,
+  acos: Math.acos,
+  acosh: Math.acosh,
+  asin: Math.asin,
+  asinh: Math.asinh,
+  atan: Math.atan,
+  atan2: Math.atan2,
+  atanh: Math.atanh,
+  cbrt: Math.cbrt,
+  ceil: Math.ceil,
+  cos: Math.cos,
+  cosh: Math.cosh,
+  exp: Math.exp,
+  expm1: Math.expm1,
+  floor: Math.floor,
+  hypot: Math.hypot,
+  log: Math.log,
+  log1p: Math.log1p,
+  log2: Math.log2,
+  log10: Math.log10,
+  max: Math.max,
+  min: Math.min,
+  pow: Math.pow,
+  random: (maximum = 1) => Math.random() * maximum,
+  round: Math.round,
+  sign: Math.sign,
+  sin: Math.sin,
+  sinh: Math.sinh,
+  sqrt: Math.sqrt,
+  tan: Math.tan,
+  tanh: Math.tanh,
+  trunc: Math.trunc
+};
+var constants = { E: Math.E, PI: Math.PI };
+function normalizeExpression(source) {
+  return source.trim().replace(/^(?:#|\$)\{/, "").replace(/\}$/, "").replace(/Math\.(random|min|max|abs|floor|ceil|round|sqrt|pow|sin|cos|tan|asin|acos|atan|sinh|cosh|tanh|asinh|acosh|atanh|cbrt|log|log2|log10|exp|expm1|log1p|trunc|sign|hypot|atan2)/g, "$1").replace(/Math\.(PI|E)\b/g, "$1").replace(/Mascot\./gi, "mascot.").replace(/TargetX|目的地X/gi, "targetX").replace(/TargetY|目的地Y/gi, "targetY").replace(/FootX|足X/gi, "footX").replace(/FootY|足Y/gi, "footY").replace(/MaxCount/gi, "maxCount").replace(/Gap/gi, "gap").replace(/\band\b/gi, "&&").replace(/\bor\b/gi, "||").replace(/\bnot\b/gi, "!");
+}
+function tokenize(source) {
+  const tokens = [];
+  let index = 0;
+  while (index < source.length) {
+    const rest = source.slice(index);
+    const whitespace = /^\s+/.exec(rest);
+    if (whitespace) {
+      index += whitespace[0].length;
+      continue;
+    }
+    const number = /^(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?/i.exec(rest);
+    if (number) {
+      tokens.push({ kind: "number", value: number[0] });
+      index += number[0].length;
+      continue;
+    }
+    const identifier = /^[A-Za-z_$\u0080-\uFFFF][\w$\u0080-\uFFFF]*/u.exec(rest);
+    if (identifier) {
+      tokens.push({ kind: "identifier", value: identifier[0] });
+      index += identifier[0].length;
+      continue;
+    }
+    const operator = /^(?:===|!==|==|!=|<=|>=|&&|\|\||[+\-*/%^<>!?:.,()])/.exec(rest);
+    if (!operator) throw new SyntaxError(`Unexpected token at ${index}`);
+    const value = operator[0];
+    tokens.push({ kind: value === "(" || value === ")" || value === "," || value === "." ? "punctuation" : "operator", value });
+    index += value.length;
+  }
+  tokens.push({ kind: "eof", value: "" });
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  index = 0;
+  parse() {
+    const node = this.parseConditional();
+    if (this.peek().kind !== "eof") throw new SyntaxError(`Unexpected '${this.peek().value}'`);
+    return node;
+  }
+  peek() {
+    return this.tokens[this.index] ?? { kind: "eof", value: "" };
+  }
+  take(value) {
+    const token = this.peek();
+    if (value !== void 0 && token.value !== value) throw new SyntaxError(`Expected '${value}'`);
+    this.index += 1;
+    return token;
+  }
+  match(...values) {
+    if (!values.includes(this.peek().value)) return false;
+    this.index += 1;
+    return true;
+  }
+  parseConditional() {
+    const test = this.parseOr();
+    if (!this.match("?")) return test;
+    const consequent = this.parseConditional();
+    this.take(":");
+    return { kind: "conditional", test, consequent, alternate: this.parseConditional() };
+  }
+  parseOr() {
+    return this.binary(() => this.parseAnd(), ["||"]);
+  }
+  parseAnd() {
+    return this.binary(() => this.parseEquality(), ["&&"]);
+  }
+  parseEquality() {
+    return this.binary(() => this.parseComparison(), ["==", "===", "!=", "!=="]);
+  }
+  parseComparison() {
+    return this.binary(() => this.parseAdditive(), ["<", "<=", ">", ">="]);
+  }
+  parseAdditive() {
+    return this.binary(() => this.parseMultiplicative(), ["+", "-"]);
+  }
+  parseMultiplicative() {
+    return this.binary(() => this.parsePower(), ["*", "/", "%"]);
+  }
+  parsePower() {
+    return this.binary(() => this.parseUnary(), ["^"]);
+  }
+  binary(next, operators) {
+    let left = next();
+    while (operators.includes(this.peek().value)) {
+      const operator = this.take().value;
+      left = { kind: "binary", operator, left, right: next() };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (["!", "+", "-"].includes(this.peek().value)) {
+      return { kind: "unary", operator: this.take().value, argument: this.parseUnary() };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let node = this.parsePrimary();
+    for (; ; ) {
+      if (this.match(".")) {
+        const property = this.take();
+        if (property.kind !== "identifier" || forbiddenProperties.has(property.value)) throw new SyntaxError("Unsafe member access");
+        node = { kind: "member", object: node, property: property.value };
+      } else if (this.match("(")) {
+        const args = [];
+        if (!this.match(")")) {
+          do {
+            args.push(this.parseConditional());
+          } while (this.match(","));
+          this.take(")");
+        }
+        node = { kind: "call", callee: node, args };
+      } else return node;
+    }
+  }
+  parsePrimary() {
+    const token = this.take();
+    if (token.kind === "number") return { kind: "literal", value: Number(token.value) };
+    if (token.kind === "identifier") {
+      if (token.value === "true" || token.value === "false") return { kind: "literal", value: token.value === "true" };
+      return { kind: "identifier", name: token.value };
+    }
+    if (token.value === "(") {
+      const node = this.parseConditional();
+      this.take(")");
+      return node;
+    }
+    throw new SyntaxError(`Unexpected '${token.value}'`);
+  }
+};
+function resolveMember(node, scope) {
+  const owner = evaluateNode(node.object, scope);
+  if (typeof owner !== "object" && typeof owner !== "function" || owner === null) return { owner, value: void 0 };
+  if (forbiddenProperties.has(node.property)) return { owner, value: void 0 };
+  return { owner, value: owner[node.property] };
+}
+function evaluateNode(node, scope) {
+  switch (node.kind) {
+    case "literal":
+      return node.value;
+    case "identifier":
+      return Object.hasOwn(scope, node.name) ? scope[node.name] : functions[node.name] ?? constants[node.name];
+    case "member":
+      return resolveMember(node, scope).value;
+    case "call": {
+      const member = node.callee.kind === "member" ? resolveMember(node.callee, scope) : void 0;
+      const callable = member?.value ?? evaluateNode(node.callee, scope);
+      if (typeof callable !== "function") throw new TypeError("Expression value is not callable");
+      return callable.apply(member?.owner, node.args.map((argument) => evaluateNode(argument, scope)));
+    }
+    case "unary": {
+      const value = evaluateNode(node.argument, scope);
+      if (node.operator === "!") return !value;
+      if (node.operator === "+") return Number(value);
+      return -Number(value);
+    }
+    case "conditional":
+      return evaluateNode(node.test, scope) ? evaluateNode(node.consequent, scope) : evaluateNode(node.alternate, scope);
+    case "binary": {
+      if (node.operator === "&&") return Boolean(evaluateNode(node.left, scope)) && Boolean(evaluateNode(node.right, scope));
+      if (node.operator === "||") return Boolean(evaluateNode(node.left, scope)) || Boolean(evaluateNode(node.right, scope));
+      const left = evaluateNode(node.left, scope);
+      const right = evaluateNode(node.right, scope);
+      switch (node.operator) {
+        case "+":
+          return Number(left) + Number(right);
+        case "-":
+          return Number(left) - Number(right);
+        case "*":
+          return Number(left) * Number(right);
+        case "/":
+          return Number(left) / Number(right);
+        case "%":
+          return Number(left) % Number(right);
+        case "^":
+          return Math.pow(Number(left), Number(right));
+        case "==":
+        case "===":
+          return left === right;
+        case "!=":
+        case "!==":
+          return left !== right;
+        case "<":
+          return Number(left) < Number(right);
+        case "<=":
+          return Number(left) <= Number(right);
+        case ">":
+          return Number(left) > Number(right);
+        case ">=":
+          return Number(left) >= Number(right);
+        default:
+          return false;
+      }
+    }
+  }
+}
+var expressionCache = /* @__PURE__ */ new Map();
+function evaluateExpression(expression, environment, fallback) {
+  if (expression === void 0) return fallback;
+  if (typeof expression !== "string") return expression;
+  try {
+    const normalized = normalizeExpression(expression);
+    let ast = expressionCache.get(normalized);
+    if (!ast) {
+      ast = new Parser(tokenize(normalized)).parse();
+      expressionCache.set(normalized, ast);
+    }
+    const result = evaluateNode(ast, environment);
+    if (typeof fallback === "boolean") return Boolean(result);
+    const numericResult = Number(result);
+    return Number.isNaN(numericResult) ? fallback : numericResult;
+  } catch {
+    return fallback;
+  }
+}
+function conditionsMatch(conditions, environment) {
+  return conditions.every((condition) => evaluateExpression(condition, environment, false));
+}
+function selectWeighted(items, weight, random = Math.random) {
+  const weighted = items.map((item) => ({ item, weight: Math.max(0, weight(item)) }));
+  const total = weighted.reduce((sum, entry) => sum + entry.weight, 0);
+  if (total <= 0) return void 0;
+  let cursor = random() * total;
+  for (const entry of weighted) {
+    cursor -= entry.weight;
+    if (cursor < 0) return entry.item;
+  }
+  return weighted.at(-1)?.item;
+}
+var BehaviorController = class {
+  /** Creates a behavior selector for a normalized character specification. */
+  constructor(spec, random = Math.random) {
+    this.spec = spec;
+    this.random = random;
+  }
+  spec;
+  random;
+  previous;
+  /** Selects an initial behavior, honoring an explicit requested name when possible. */
+  selectInitial(environment, requestedName) {
+    if (requestedName) {
+      const requested = this.spec.behaviors.find((behavior) => behavior.name === requestedName);
+      if (requested && conditionsMatch(requested.conditions, environment)) return this.previous = this.resolve(requested);
+    }
+    const fall = this.findFallBehavior();
+    if (fall && !this.isOnAnyBoundary(environment)) return this.previous = fall;
+    return this.previous = this.choose(this.spec.behaviors, environment);
+  }
+  /** Selects the weighted transition following the current behavior. */
+  selectNext(environment) {
+    const pool = this.previous?.nextBehaviors.length ? this.previous.nextBehaviors : this.spec.behaviors;
+    return this.previous = this.choose(pool, environment) ?? this.findFallBehavior();
+  }
+  /** Replaces selection history so an external interaction can force a behavior. */
+  force(name) {
+    const behavior = this.spec.behaviors.find((candidate) => candidate.name === name);
+    return this.previous = behavior ? this.resolve(behavior) : void 0;
+  }
+  choose(pool, environment) {
+    const applicable = pool.filter((behavior) => conditionsMatch(behavior.conditions, environment));
+    const chosen = selectWeighted(applicable, (behavior) => behavior.frequency, this.random);
+    return chosen ? this.resolve(chosen) : void 0;
+  }
+  resolve(behavior) {
+    if (behavior.type !== "Reference") return behavior;
+    const target = this.spec.behaviors.find((candidate) => candidate.type === "Behavior" && candidate.name === behavior.name);
+    return target ? { ...target, ...behavior, type: "Behavior", nextBehaviors: target.nextBehaviors } : { ...behavior, type: "Behavior" };
+  }
+  findFallBehavior() {
+    return this.spec.behaviors.find((behavior) => behavior.name === "Fall" || behavior.name === "\u843D\u4E0B\u3059\u308B");
+  }
+  isOnAnyBoundary(environment) {
+    const anchor = environment.mascot.anchor;
+    const area = environment.mascot.environment.workArea;
+    return area.topBorder.isOn(anchor) || area.leftBorder.isOn(anchor) || area.rightBorder.isOn(anchor) || area.bottomBorder.isOn(anchor);
+  }
+};
+
+// src/physics.ts
+function clamp(value, minimum, maximum) {
+  return Math.min(Math.max(value, minimum), maximum);
+}
+function isOnTop(point, rectangle, tolerance = 1) {
+  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y) <= tolerance;
+}
+function isOnBottom(point, rectangle, tolerance = 1) {
+  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y - rectangle.height) <= tolerance;
+}
+function isOnLeft(point, rectangle, tolerance = 1) {
+  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x) <= tolerance;
+}
+function isOnRight(point, rectangle, tolerance = 1) {
+  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x - rectangle.width) <= tolerance;
+}
+function isOnBorder(state, bounds, border) {
+  if (!border) return true;
+  if (border === "Floor") return isOnBottom(state, bounds);
+  if (border === "Ceiling") return isOnTop(state, bounds);
+  return isOnLeft(state, bounds) || isOnRight(state, bounds);
+}
+function applyGravity(state, bounds, frameScale, gravity, resistanceX = 0.05, resistanceY = 0.01) {
+  state.x = clamp(state.x + state.vx * frameScale, bounds.x, bounds.x + bounds.width);
+  state.y = clamp(state.y + state.vy * frameScale, bounds.y, bounds.y + bounds.height);
+  state.vx *= Math.max(0, 1 - resistanceX * frameScale);
+  state.vy = state.vy * Math.max(0, 1 - resistanceY * frameScale) + gravity * frameScale;
+  if (state.y >= bounds.y + bounds.height) {
+    state.y = bounds.y + bounds.height;
+    state.vy = 0;
+    return true;
+  }
+  if (state.x <= bounds.x || state.x >= bounds.x + bounds.width) {
+    state.vx = 0;
+    return true;
+  }
+  return false;
+}
+function moveToward(state, target, speed, frameScale) {
+  const dx = target.x - state.x;
+  const dy = target.y - state.y;
+  const distance = Math.hypot(dx, dy);
+  if (distance <= Math.max(1e-3, speed * frameScale)) {
+    state.x = target.x;
+    state.y = target.y;
+    return true;
+  }
+  state.x += dx / distance * speed * frameScale;
+  state.y += dy / distance * speed * frameScale;
+  return false;
+}
+
+// src/action.ts
+function numeric(value, environment) {
+  return value === void 0 ? void 0 : evaluateExpression(value, environment, 0);
+}
+function evaluateAction(definition, environment) {
+  const gap = numeric(definition.gap, environment) ?? 0;
+  const scopedEnvironment = { ...environment, gap };
+  const targetX = numeric(definition.targetX, scopedEnvironment);
+  const initialVx = numeric(definition.initialVx, scopedEnvironment);
+  let lookRight = environment.mascot.lookRight;
+  if (definition.borderType === "Wall") {
+    lookRight = environment.mascot.environment.workArea.rightBorder.isOn(environment.mascot.anchor);
+  } else if (definition.type === "Move" || definition.embedType === "Jump" || definition.embedType === "WalkWithIE") {
+    if (targetX !== void 0) lookRight = targetX > environment.mascot.anchor.x;
+  } else if (definition.embedType === "Fall" || definition.embedType === "FallWithIE") {
+    if (initialVx !== void 0 && initialVx !== 0) lookRight = initialVx > 0;
+  } else if (definition.embedType === "Look") {
+    lookRight = definition.lookRight === void 0 ? !environment.mascot.lookRight : typeof definition.lookRight === "boolean" ? definition.lookRight : evaluateExpression(definition.lookRight, scopedEnvironment, environment.mascot.lookRight);
+  }
+  const duration = numeric(definition.duration, scopedEnvironment);
+  const targetY = numeric(definition.targetY, scopedEnvironment);
+  const velocity = numeric(definition.velocity, scopedEnvironment);
+  const x = numeric(definition.x, scopedEnvironment);
+  const y = numeric(definition.y, scopedEnvironment);
+  const initialVy = numeric(definition.initialVy, scopedEnvironment);
+  const resistanceX = numeric(definition.resistanceX, scopedEnvironment);
+  const resistanceY = numeric(definition.resistanceY, scopedEnvironment);
+  const gravity = numeric(definition.gravity, scopedEnvironment);
+  const bornX = numeric(definition.bornX, scopedEnvironment);
+  const bornY = numeric(definition.bornY, scopedEnvironment);
+  return {
+    definition,
+    lookRight,
+    ...duration !== void 0 && { duration },
+    ...targetX !== void 0 && { targetX },
+    ...targetY !== void 0 && { targetY },
+    ...velocity !== void 0 && { velocity },
+    ...x !== void 0 && { x },
+    ...y !== void 0 && { y },
+    ...initialVx !== void 0 && { initialVx },
+    ...initialVy !== void 0 && { initialVy },
+    ...resistanceX !== void 0 && { resistanceX },
+    ...resistanceY !== void 0 && { resistanceY },
+    ...gravity !== void 0 && { gravity },
+    ...bornX !== void 0 && { bornX },
+    ...bornY !== void 0 && { bornY }
+  };
+}
+var SequenceRuntime = class {
+  constructor(definitions, factory, loop) {
+    this.definitions = definitions;
+    this.factory = factory;
+    this.loop = loop;
+  }
+  definitions;
+  factory;
+  loop;
+  index = 0;
+  child;
+  tick(deltaMs, environment, bounds) {
+    for (let guard = 0; guard < 32; guard += 1) {
+      const definition = this.definitions[this.index];
+      if (!definition) {
+        if (!this.loop || this.definitions.length === 0) return true;
+        this.index = 0;
+        continue;
+      }
+      this.child ??= this.factory(definition, environment);
+      if (!this.child.tick(deltaMs, environment, bounds)) return false;
+      this.child = void 0;
+      this.index += 1;
+      deltaMs = 0;
+    }
+    return false;
+  }
+};
+var CompleteRuntime = class {
+  tick() {
+    return true;
+  }
+};
+var LeafRuntime = class {
+  constructor(action, state, options, callbacks, environment) {
+    this.action = action;
+    this.state = state;
+    this.options = options;
+    this.callbacks = callbacks;
+    const animationEnvironment = { ...environment, ...action.targetX !== void 0 && { targetX: action.targetX }, ...action.targetY !== void 0 && { targetY: action.targetY } };
+    this.animation = action.definition.animations?.find((animation) => !animation.condition || evaluateExpression(animation.condition, animationEnvironment, false)) ?? action.definition.animations?.find((animation) => !animation.condition) ?? action.definition.animations?.[0];
+    this.poseDuration = this.animation?.poses.reduce((sum, pose) => sum + Math.max(0, pose.duration), 0) ?? 0;
+  }
+  action;
+  state;
+  options;
+  callbacks;
+  elapsedMs = 0;
+  started = false;
+  spawned = false;
+  animation;
+  poseDuration;
+  tick(deltaMs, environment, bounds) {
+    const frameScale = deltaMs / this.options.frameDuration;
+    if (!this.started) {
+      this.started = true;
+      this.state.lookRight = this.action.lookRight;
+      this.initialize();
+    }
+    this.elapsedMs += deltaMs;
+    const pose = this.currentPose();
+    if (pose) this.applyPose(pose, frameScale, bounds);
+    const { definition } = this.action;
+    if (definition.type === "Embedded") return this.tickEmbedded(frameScale, environment, bounds);
+    if (definition.type === "Move" && (this.action.targetX !== void 0 || this.action.targetY !== void 0)) {
+      const reachedX = this.action.targetX === void 0 || Math.abs(this.state.x - this.action.targetX) < 0.5;
+      const reachedY = this.action.targetY === void 0 || Math.abs(this.state.y - this.action.targetY) < 0.5;
+      return reachedX && reachedY;
+    }
+    return this.elapsedMs >= this.durationMs();
+  }
+  initialize() {
+    const type = this.action.definition.embedType;
+    if (type === "Fall" || type === "FallWithIE") {
+      this.state.vx = this.action.initialVx ?? this.state.vx;
+      this.state.vy = this.action.initialVy ?? this.state.vy;
+    }
+    if (type === "Offset") {
+      this.state.x += this.action.x ?? 0;
+      this.state.y += this.action.y ?? 0;
+    }
+    if (type === "Reboot") {
+      this.state.vx = 0;
+      this.state.vy = 0;
+    }
+  }
+  tickEmbedded(frameScale, environment, bounds) {
+    switch (this.action.definition.embedType) {
+      case "Fall":
+      case "FallWithIE":
+      case "Thrown":
+        return applyGravity(this.state, bounds, frameScale, this.action.gravity ?? this.options.gravity, this.action.resistanceX, this.action.resistanceY);
+      case "Jump": {
+        const target = { x: this.action.targetX ?? this.state.x, y: this.action.targetY ?? this.state.y };
+        return moveToward(this.state, target, this.action.velocity ?? 20, frameScale);
+      }
+      case "Breed":
+        if (!this.spawned && this.elapsedMs >= this.durationMs()) {
+          this.spawned = true;
+          const child = { x: this.state.x + (this.action.bornX ?? 0), y: this.state.y + (this.action.bornY ?? 0) };
+          this.callbacks.spawn(this.action.definition.bornBehavior ? { ...child, behaviorName: this.action.definition.bornBehavior } : child);
+          return true;
+        }
+        return false;
+      case "Exit":
+        this.callbacks.remove();
+        return true;
+      case "Reboot":
+        this.state.x = bounds.x + 128 + Math.max(0, bounds.width - 256) * Math.random();
+        this.state.y = bounds.y + 128 + Math.max(0, bounds.height - 256) * Math.random();
+        return true;
+      case "Offset":
+      case "Look":
+        return true;
+      case "Dragged":
+        return false;
+      default:
+        return this.elapsedMs >= this.durationMs();
+    }
+  }
+  currentPose() {
+    if (!this.animation?.poses.length || this.poseDuration <= 0) return void 0;
+    let cursor = this.elapsedMs / this.options.frameDuration % this.poseDuration;
+    for (const pose of this.animation.poses) {
+      cursor -= pose.duration;
+      if (cursor < 0) return pose;
+    }
+    return this.animation.poses.at(-1);
+  }
+  applyPose(pose, frameScale, bounds) {
+    this.state.sprite = pose.sprite;
+    this.state.anchorX = pose.anchor.x;
+    this.state.anchorY = pose.anchor.y;
+    const direction = this.state.lookRight ? -1 : 1;
+    this.state.x = clamp(this.state.x + pose.velocity.x * direction * frameScale, bounds.x, bounds.x + bounds.width);
+    this.state.y = clamp(this.state.y + pose.velocity.y * frameScale, bounds.y, bounds.y + bounds.height);
+  }
+  durationMs() {
+    const frames = this.action.duration ?? this.poseDuration;
+    return Math.max(this.options.frameDuration, frames * this.options.frameDuration);
+  }
+};
+var ActionExecutor = class {
+  /** Creates an executor bound to one mascot's mutable internal state. */
+  constructor(spec, state, options, callbacks) {
+    this.spec = spec;
+    this.state = state;
+    this.options = options;
+    this.callbacks = callbacks;
+  }
+  spec;
+  state;
+  options;
+  callbacks;
+  runtime;
+  /** Starts the action whose name matches a selected behavior. */
+  start(actionName, environment) {
+    const definition = this.spec.actions.find((action) => action.name === actionName);
+    this.runtime = definition ? this.createRuntime(definition, environment, /* @__PURE__ */ new Set()) : void 0;
+    return this.runtime !== void 0;
+  }
+  /** Advances the current action and returns true when it has completed. */
+  tick(deltaMs, environment, bounds) {
+    return this.runtime?.tick(deltaMs, environment, bounds) ?? true;
+  }
+  /** Cancels the current action tree. */
+  cancel() {
+    this.runtime = void 0;
+  }
+  createRuntime(definition, environment, references) {
+    if (definition.condition && !evaluateExpression(definition.condition, environment, false)) return new CompleteRuntime();
+    const bounds = environment.mascot.environment.workArea;
+    if (!isOnBorder(this.state, bounds, definition.borderType)) return new CompleteRuntime();
+    if (definition.type === "Reference") {
+      if (!definition.name || references.has(definition.name)) return new CompleteRuntime();
+      const referenced = this.spec.actions.find((action) => action.name === definition.name);
+      if (!referenced) return new CompleteRuntime();
+      const nextReferences = new Set(references).add(definition.name);
+      return this.createRuntime({ ...referenced, ...definition, type: referenced.type }, environment, nextReferences);
+    }
+    if (definition.type === "Sequence") {
+      return new SequenceRuntime(definition.actions ?? [], (child, nextEnvironment) => this.createRuntime(child, nextEnvironment, new Set(references)), definition.loop === true);
+    }
+    if (definition.type === "Select") {
+      const child = definition.actions?.find((candidate) => !candidate.condition || evaluateExpression(candidate.condition, environment, false));
+      return child ? this.createRuntime(child, environment, new Set(references)) : new CompleteRuntime();
+    }
+    return new LeafRuntime(evaluateAction(definition, environment), this.state, this.options, this.callbacks, environment);
+  }
+};
+
+// src/mascot.ts
+function edge(predicate) {
+  return { isOn: predicate };
+}
+function environmentRectangle(bounds) {
+  const left = bounds.x;
+  const right = bounds.x + bounds.width;
+  const top = bounds.y;
+  const bottom = bounds.y + bounds.height;
+  return {
+    ...bounds,
+    left,
+    right,
+    top,
+    bottom,
+    topBorder: edge((point) => Math.abs(point.y - top) <= 1),
+    leftBorder: edge((point) => Math.abs(point.x - left) <= 1),
+    rightBorder: edge((point) => Math.abs(point.x - right) <= 1),
+    bottomBorder: edge((point) => Math.abs(point.y - bottom) <= 1)
+  };
+}
+var Mascot = class {
+  /** Creates a mascot and immediately installs its pointer handlers. */
+  constructor(id, spec, dom, options, spawnOptions, callbacks) {
+    this.id = id;
+    this.spec = spec;
+    this.dom = dom;
+    this.callbacks = callbacks;
+    const initialPose = spec.actions.flatMap((action) => action.animations ?? []).flatMap((animation) => animation.poses)[0];
+    this.state = {
+      id,
+      characterId: spec.id,
+      x: spawnOptions.x ?? 0,
+      y: spawnOptions.y ?? 0,
+      vx: spawnOptions.vx ?? 0,
+      vy: spawnOptions.vy ?? 0,
+      sprite: initialPose?.sprite ?? Object.keys(spec.sprites)[0] ?? "",
+      anchorX: initialPose?.anchor.x ?? 64,
+      anchorY: initialPose?.anchor.y ?? 128,
+      lookRight: spawnOptions.lookRight ?? false,
+      behaviorName: spawnOptions.behaviorName ?? "Fall",
+      dragging: false
+    };
+    this.domHandle = dom.createMascot(spec, id, options.mascotClassName || void 0);
+    this.behavior = new BehaviorController(spec, options.random);
+    this.actions = new ActionExecutor(spec, this.state, options, {
+      spawn: (position) => this.callbacks.spawn(this.spec.id, position),
+      remove: () => this.callbacks.remove(this.id)
+    });
+    this.installPointerHandlers();
+  }
+  id;
+  spec;
+  dom;
+  callbacks;
+  /** Mutable internal state; callers should consume snapshots from the engine. */
+  state;
+  domHandle;
+  behavior;
+  actions;
+  disposers = [];
+  currentBehavior;
+  destroyed = false;
+  dragOffset = { x: 0, y: 0 };
+  pointerId;
+  pointerDown;
+  lastPointer;
+  /** Advances behavior, animation, physics, and rendering by one clock tick. */
+  tick(deltaMs, bounds) {
+    if (this.destroyed) return;
+    const environment = this.createEnvironment(bounds);
+    if (this.state.dragging) {
+      this.dom.render(this.domHandle, this.spec, this.state);
+      return;
+    }
+    try {
+      for (let guard = 0; guard < 8; guard += 1) {
+        if (!this.currentBehavior) {
+          this.currentBehavior = this.behavior.selectInitial(environment, this.state.behaviorName);
+          let started = this.startBehavior(environment);
+          if (!started) {
+            this.currentBehavior = this.findFallBehavior();
+            started = this.startBehavior(environment);
+          }
+          if (!started) break;
+        }
+        if (!this.actions.tick(deltaMs, environment, bounds)) break;
+        if (this.destroyed) return;
+        this.currentBehavior = this.behavior.selectNext(this.createEnvironment(bounds));
+        if (!this.currentBehavior || !this.startBehavior(this.createEnvironment(bounds))) {
+          this.currentBehavior = this.findFallBehavior();
+          if (!this.currentBehavior || !this.startBehavior(this.createEnvironment(bounds))) break;
+        }
+        deltaMs = 0;
+      }
+    } catch (error) {
+      this.callbacks.error(error instanceof Error ? error : new Error(String(error)));
+      this.currentBehavior = void 0;
+      this.actions.cancel();
+    }
+    this.dom.render(this.domHandle, this.spec, this.state);
+  }
+  /** Returns a detached snapshot safe for application code to retain. */
+  snapshot() {
+    return { ...this.state };
+  }
+  /** Removes listeners, DOM nodes, and object URLs owned by this mascot. */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.actions.cancel();
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.dom.removeMascot(this.domHandle);
+  }
+  startBehavior(environment) {
+    if (!this.currentBehavior) return false;
+    this.state.behaviorName = this.currentBehavior.name;
+    return this.actions.start(this.currentBehavior.name, environment);
+  }
+  findFallBehavior() {
+    return this.behavior.force("Fall") ?? this.behavior.force("\u843D\u4E0B\u3059\u308B");
+  }
+  createEnvironment(bounds) {
+    const workArea = environmentRectangle(bounds);
+    const inactive = environmentRectangle({ x: -100, y: -100, width: 0, height: 0 });
+    return {
+      gap: 0,
+      maxCount: 999,
+      mascot: {
+        totalCount: this.callbacks.count(),
+        anchor: { x: this.state.x, y: this.state.y },
+        lookRight: this.state.lookRight,
+        environment: {
+          cursor: this.callbacks.pointer(),
+          screen: { width: window.innerWidth, height: window.innerHeight },
+          workArea,
+          floor: workArea.bottomBorder,
+          ceiling: workArea.topBorder,
+          activeIE: { ...inactive, visible: false }
+        }
+      }
+    };
+  }
+  installPointerHandlers() {
+    const element = this.domHandle.element;
+    const listen = (target, type, listener) => {
+      target.addEventListener(type, listener);
+      this.disposers.push(() => target.removeEventListener(type, listener));
+    };
+    listen(element, "pointerdown", (event) => {
+      const pointerEvent = event;
+      if (pointerEvent.button !== 0) return;
+      event.preventDefault();
+      const bounds = this.dom.workArea.getBoundingClientRect();
+      const point = { x: pointerEvent.clientX - bounds.left, y: pointerEvent.clientY - bounds.top };
+      this.pointerId = pointerEvent.pointerId;
+      this.pointerDown = point;
+      this.lastPointer = point;
+      this.dragOffset = { x: this.state.x - point.x, y: this.state.y - point.y };
+      this.state.dragging = true;
+      this.actions.cancel();
+      this.currentBehavior = this.behavior.force("Dragged") ?? this.behavior.force("\u30C9\u30E9\u30C3\u30B0\u3055\u308C\u308B");
+      if (this.currentBehavior) this.state.behaviorName = this.currentBehavior.name;
+      element.setPointerCapture?.(pointerEvent.pointerId);
+    });
+    listen(document, "pointermove", (event) => {
+      const pointerEvent = event;
+      if (!this.state.dragging || pointerEvent.pointerId !== this.pointerId) return;
+      const bounds = this.dom.workArea.getBoundingClientRect();
+      const point = { x: pointerEvent.clientX - bounds.left, y: pointerEvent.clientY - bounds.top };
+      const previous = this.lastPointer ?? point;
+      this.state.vx = (point.x - previous.x) * 0.8;
+      this.state.vy = (point.y - previous.y) * 0.8;
+      this.state.x = point.x + this.dragOffset.x;
+      this.state.y = point.y + this.dragOffset.y;
+      this.lastPointer = point;
+    });
+    listen(document, "pointerup", (event) => {
+      const pointerEvent = event;
+      if (!this.state.dragging || pointerEvent.pointerId !== this.pointerId) return;
+      this.state.dragging = false;
+      const moved = this.pointerDown ? Math.hypot(this.lastPointer.x - this.pointerDown.x, this.lastPointer.y - this.pointerDown.y) : 0;
+      this.pointerId = void 0;
+      this.currentBehavior = this.behavior.force("Thrown") ?? this.behavior.force("\u6295\u3052\u3089\u308C\u308B") ?? this.findFallBehavior();
+      if (this.currentBehavior) {
+        this.state.behaviorName = this.currentBehavior.name;
+        this.actions.start(this.currentBehavior.name, this.createEnvironment(this.dom.getBounds()));
+      }
+      if (moved < 4) this.callbacks.click(this.snapshot());
+    });
+  }
+};
+
+// src/sprite.ts
+function dataUriToBlob(source) {
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(source);
+  if (!match) throw new TypeError("Invalid image data URI");
+  const mimeType = match[1] ?? "application/octet-stream";
+  const encoded = match[3] ?? "";
+  const binary = match[2] ? atob(encoded) : decodeURIComponent(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return new Blob([bytes], { type: mimeType });
+}
+var SpriteManager = class {
+  leases = /* @__PURE__ */ new Set();
+  /** Creates a separately releasable spritesheet lease for a mascot. */
+  acquire(source) {
+    let url = typeof source === "string" ? source : "";
+    let owned = false;
+    if (typeof URL.createObjectURL === "function" && (typeof source !== "string" || source.startsWith("data:image"))) {
+      try {
+        url = URL.createObjectURL(typeof source === "string" ? dataUriToBlob(source) : source);
+        owned = true;
+      } catch {
+        if (typeof source !== "string") throw new Error("The current environment cannot create a URL for the spritesheet Blob");
+      }
+    }
+    let released = false;
+    const lease = {
+      url,
+      release: () => {
+        if (released) return;
+        released = true;
+        this.leases.delete(lease);
+        if (owned) URL.revokeObjectURL(url);
+      }
+    };
+    this.leases.add(lease);
+    return lease;
+  }
+  /** Resolves a sprite key using a lease and the character's sprite map. */
+  resolve(spec, lease, spriteName) {
+    const key = Object.keys(spec.sprites).find((candidate) => candidate.toLowerCase() === spriteName.toLowerCase());
+    const sprite = key ? spec.sprites[key] : void 0;
+    if (typeof sprite === "string") return { url: sprite };
+    if (sprite && "url" in sprite && typeof sprite.url === "string" && !("x" in sprite)) return { url: sprite.url };
+    if (sprite && "x" in sprite) return { url: sprite.url ?? lease.url, rectangle: sprite };
+    if (/^(?:data:|blob:|https?:|\/)/.test(spriteName)) return { url: spriteName };
+    return void 0;
+  }
+  /** Revokes every object URL that has not already been released. */
+  destroy() {
+    for (const lease of [...this.leases]) lease.release();
+  }
+};
+function isIndividualSprite(sprite) {
+  return typeof sprite === "object" && "url" in sprite && !("x" in sprite);
+}
+
+// src/engine.ts
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    const listeners = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.listeners.set(event, listeners);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  emit(event, payload) {
+    for (const listener of [...this.listeners.get(event) ?? []]) listener(payload);
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+var defaults = {
+  frameDuration: 40,
+  gravity: 2,
+  maxDeltaTime: 100,
+  workAreaClassName: "",
+  mascotClassName: ""
+};
+var ShimejiEngine = class {
+  /** Creates and initializes an engine inside a host DOM element. */
+  constructor(container, options = {}) {
+    this.container = container;
+    if (!container) throw new TypeError("ShimejiEngine requires a container element");
+    this.options = { ...defaults, ...options, random: options.random };
+    this.originalContainerPosition = container.style.position;
+    this.adjustedContainerPosition = getComputedStyle(container).position === "static";
+    if (this.adjustedContainerPosition) container.style.position = "relative";
+    this.dom = new DomManager(container, this.sprites, this.options.workAreaClassName || void 0);
+    this.initialize();
+  }
+  container;
+  specs = /* @__PURE__ */ new Map();
+  mascots = /* @__PURE__ */ new Map();
+  sprites = new SpriteManager();
+  dom;
+  events = new EventEmitter();
+  disposers = [];
+  intervals = /* @__PURE__ */ new Set();
+  options;
+  originalContainerPosition;
+  adjustedContainerPosition;
+  pointer = { x: 0, y: 0, dx: 0, dy: 0 };
+  animationFrame;
+  lastFrameTime;
+  nextMascotId = 1;
+  destroyed = false;
+  initialized = false;
+  /** Starts the clock and global listeners. Calling this method more than once is harmless. */
+  initialize() {
+    this.assertAlive();
+    if (this.initialized) return;
+    this.initialized = true;
+    this.listen(document, "pointermove", (event) => {
+      const pointerEvent = event;
+      const rectangle = this.dom.workArea.getBoundingClientRect();
+      const x = pointerEvent.clientX - rectangle.left;
+      const y = pointerEvent.clientY - rectangle.top;
+      this.pointer = { x, y, dx: x - this.pointer.x, dy: y - this.pointer.y };
+    });
+    this.listen(window, "resize", () => this.renderAll());
+    const maintenance = window.setInterval(() => this.dom.ensureMounted(), 2e3);
+    this.intervals.add(maintenance);
+    this.animationFrame = requestAnimationFrame(this.onAnimationFrame);
+  }
+  /** Registers or replaces a parsed or legacy character specification. */
+  registerCharacter(spec) {
+    this.assertAlive();
+    const normalized = normalizeCharacterSpec(spec);
+    this.specs.set(normalized.id, normalized);
+    return normalized.id;
+  }
+  /** Unregisters a character and optionally removes all of its live mascots. */
+  unregisterCharacter(characterId, removeMascots = true) {
+    this.assertAlive();
+    if (removeMascots) {
+      for (const state of this.getState()) if (state.characterId === characterId) this.remove(state.id);
+    }
+    return this.specs.delete(characterId);
+  }
+  /** Returns identifiers for all currently registered characters. */
+  getCharacterIds() {
+    return [...this.specs.keys()];
+  }
+  /** Creates a mascot from a registered character and returns its instance id. */
+  spawn(characterId, position = {}) {
+    this.assertAlive();
+    const spec = this.specs.get(characterId);
+    if (!spec) throw new Error(`Character '${characterId}' is not registered`);
+    const bounds = this.dom.getBounds();
+    const random = this.options.random ?? Math.random;
+    const spawnOptions = {
+      ...position,
+      x: position.x ?? bounds.x + random() * bounds.width,
+      y: position.y ?? bounds.y + random() * bounds.height
+    };
+    const id = `shimeji-${this.nextMascotId++}`;
+    const mascot = new Mascot(id, spec, this.dom, this.options, spawnOptions, {
+      pointer: () => ({ ...this.pointer }),
+      count: () => this.mascots.size,
+      spawn: (nextCharacterId, nextPosition) => {
+        if (!this.destroyed) this.spawn(nextCharacterId, nextPosition);
+      },
+      remove: (mascotId) => {
+        if (!this.destroyed) this.remove(mascotId);
+      },
+      click: (state2) => this.events.emit("click", state2),
+      error: (error) => this.events.emit("error", error)
+    });
+    this.mascots.set(id, mascot);
+    mascot.tick(0, bounds);
+    const state = mascot.snapshot();
+    this.events.emit("spawn", state);
+    this.emitState();
+    return id;
+  }
+  /** Removes one mascot and all resources associated with it. */
+  remove(mascotId) {
+    this.assertAlive();
+    const mascot = this.mascots.get(mascotId);
+    if (!mascot) return false;
+    const state = mascot.snapshot();
+    this.mascots.delete(mascotId);
+    mascot.destroy();
+    this.events.emit("remove", state);
+    this.emitState();
+    return true;
+  }
+  /** Removes every live mascot while leaving registered character specs available. */
+  removeAll() {
+    this.assertAlive();
+    for (const id of [...this.mascots.keys()]) this.remove(id);
+  }
+  /** Returns detached snapshots of every live mascot. */
+  getState() {
+    return [...this.mascots.values()].map((mascot) => mascot.snapshot());
+  }
+  /** Subscribes to a typed engine event and returns an unsubscribe function. */
+  on(event, listener) {
+    this.assertAlive();
+    return this.events.on(event, listener);
+  }
+  /** Stops animation and timers, removes listeners and DOM, and revokes all object URLs. */
+  destroy() {
+    if (this.destroyed) return;
+    for (const mascot of this.mascots.values()) mascot.destroy();
+    this.mascots.clear();
+    if (this.animationFrame !== void 0) cancelAnimationFrame(this.animationFrame);
+    this.animationFrame = void 0;
+    for (const interval of this.intervals) window.clearInterval(interval);
+    this.intervals.clear();
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.dom.destroy();
+    this.sprites.destroy();
+    this.specs.clear();
+    this.events.clear();
+    if (this.adjustedContainerPosition && this.container.style.position === "relative") this.container.style.position = this.originalContainerPosition;
+    this.destroyed = true;
+    this.initialized = false;
+  }
+  /** Returns whether this engine has completed permanent teardown. */
+  isDestroyed() {
+    return this.destroyed;
+  }
+  onAnimationFrame = (timestamp) => {
+    if (this.destroyed) return;
+    const rawDelta = this.lastFrameTime === void 0 ? this.options.frameDuration : timestamp - this.lastFrameTime;
+    this.lastFrameTime = timestamp;
+    const delta = Math.max(0, Math.min(rawDelta, this.options.maxDeltaTime));
+    const bounds = this.dom.getBounds();
+    for (const mascot of [...this.mascots.values()]) mascot.tick(delta, bounds);
+    this.emitState();
+    this.animationFrame = requestAnimationFrame(this.onAnimationFrame);
+  };
+  renderAll() {
+    const bounds = this.dom.getBounds();
+    for (const mascot of this.mascots.values()) mascot.tick(0, bounds);
+  }
+  emitState() {
+    this.events.emit("statechange", this.getState());
+  }
+  listen(target, type, listener) {
+    target.addEventListener(type, listener);
+    this.disposers.push(() => target.removeEventListener(type, listener));
+  }
+  assertAlive() {
+    if (this.destroyed) throw new Error("ShimejiEngine has been destroyed");
+  }
+};
+export {
+  ActionExecutor,
+  BehaviorController,
+  ShimejiEngine,
+  SpriteManager,
+  applyGravity,
+  clamp,
+  conditionsMatch,
+  evaluateExpression,
+  isIndividualSprite,
+  isOnBorder,
+  isOnBottom,
+  isOnLeft,
+  isOnRight,
+  isOnTop,
+  loadCharacter,
+  moveToward,
+  normalizeCharacterSpec,
+  parseActionsXml,
+  parseBehaviorsXml,
+  selectWeighted
+};
+//# sourceMappingURL=index.js.map