@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm1/clips.js

@@ -0,0 +1,334 @@
+import { PRIMITIVE } from "./inheritance.js";
+import { Avm1Object } from "./objects.js";
+import { toInt32 } from "./operators.js";
+import { SCOPE_Target, Scope, stoppedAtPrimitive, targetPath } from "./scope.js";
+import { stringOf, toBoolean, toNumber } from "./values.js";
+/** The target, or where SetTarget found none, the root: where GotoFrame2 and a function's `this` go. */
+export function targetOrRoot(cx) {
+    if (cx.target !== null) {
+        return cx.target;
+    }
+    const root = cx.host.root?.(cx.base);
+    return (root instanceof Avm1Object ? cx.host.clipOf?.(root) : undefined) ?? cx.base;
+}
+/** The target's timeline, where it is a clip. */
+const timelineOf = (cx, target) => target === null ? null : (cx.host.timeline?.(target) ?? null);
+/** `scope` with its timeline's scope, a clip's, now `object`'s, as tellTarget makes it. */
+function retarget(scope, object) {
+    if (scope.kind === SCOPE_Target) {
+        return new Scope(scope.parent, SCOPE_Target, object, scope.depth);
+    }
+    return scope.parent === null
+        ? scope
+        : new Scope(retarget(scope.parent, object), scope.kind, scope.object, scope.depth);
+}
+/** The target `target` from here on: names resolve on its clip, or the root's where there is none. */
+function setTargetClip(cx, target) {
+    cx.target = target !== null && cx.host.removed?.(target) ? null : target;
+    const clip = cx.host.objectOf?.(targetOrRoot(cx));
+    if (clip !== undefined) {
+        cx.clip = clip;
+        cx.scope = retarget(cx.scope, clip);
+    }
+}
+/** The display object a path from `start`'s AVM1 object names, null for none or no display object. */
+export function pathTarget(cx, start, path, version) {
+    const from = cx.host.objectOf?.(start);
+    if (from === undefined) {
+        return null;
+    }
+    const object = targetPath(cx, from, path, true, false, version);
+    if (object === null && stoppedAtPrimitive && version >= 5) {
+        cx.host.trace(PRIMITIVE);
+    }
+    return object === null ? null : (cx.host.clipOf?.(object) ?? null);
+}
+/**
+ * SetTarget: the clip `path` names from the code's own clip, that clip
+ * for "", none where it names none or the code's clip is gone.
+ */
+export function setTarget(cx, path, version) {
+    if (path === "") {
+        setTargetClip(cx, cx.base);
+        return;
+    }
+    const removed = cx.host.removed?.(cx.base) ?? false;
+    setTargetClip(cx, removed ? null : pathTarget(cx, cx.base, path, version));
+}
+/**
+ * SetTarget2: as SetTarget of the value as a string, but undefined is the
+ * code's own clip up to SWF 6 and none from 7; nothing where that clip is
+ * gone.
+ */
+export function setTarget2(cx, value, version) {
+    if (cx.host.removed?.(cx.base)) {
+        cx.target = null;
+        return;
+    }
+    if (value === undefined) {
+        if (version > 6) {
+            cx.target = null;
+            const clip = cx.host.objectOf?.(cx.base);
+            if (clip !== undefined) {
+                cx.clip = cx.host.objectOf?.(targetOrRoot(cx)) ?? clip;
+                cx.scope = retarget(cx.scope, clip);
+            }
+        }
+        else {
+            setTargetClip(cx, cx.base);
+        }
+        return;
+    }
+    setTarget(cx, stringOf(value, version), version);
+}
+/**
+ * The display object a GetProperty or SetProperty names: a clip's AVM1
+ * object itself, else the path it converts to, from `start`; the empty
+ * path is `start` where `empty`, else none.
+ */
+function displayOf(cx, start, value, empty, version) {
+    if (value instanceof Avm1Object && value.display !== null) {
+        return value.display.target;
+    }
+    const path = stringOf(value, version);
+    if (!empty && path === "") {
+        return null;
+    }
+    return pathTarget(cx, start, path, version);
+}
+/** What GetProperty and SetProperty act on: from the target, or from the code's clip where there is none. */
+const propertyTarget = (cx, path, version) => cx.target !== null
+    ? displayOf(cx, cx.target, path, true, version)
+    : displayOf(cx, cx.base, path, false, version);
+/** A property's index: the number truncated, none for NaN, an infinity or -1 and below. */
+function indexOf(index, version) {
+    const n = toNumber(index, version);
+    return Number.isFinite(n) && n > -1 ? Math.trunc(n) : -1;
+}
+/** GetProperty: property `index` of the clip `path` names, undefined for none. */
+export function getProperty(cx, index, path, version) {
+    const i = indexOf(index, version);
+    const target = propertyTarget(cx, path, version);
+    if (target === null || i < 0) {
+        return undefined;
+    }
+    return cx.host.objectOf?.(target).display?.property(i, version);
+}
+/** SetProperty: property `index` of the clip `path` names set to `value`. */
+export function setProperty(cx, value, index, path, version) {
+    const i = indexOf(index, version);
+    const target = propertyTarget(cx, path, version);
+    if (target === null) {
+        // The value is converted all the same (Ruffle's action_property_coerce).
+        coerceFor(i, value, version);
+        return;
+    }
+    if (i >= 0) {
+        cx.host.objectOf?.(target).display?.setProperty(i, value, version);
+    }
+}
+/**
+ * What a property's set converts its value to before it finds the target
+ * read-only or missing: a number for 0 to 12 but `_target` (11), a string
+ * for `_name` and `_quality`, a number for the rest but `_focusrect`.
+ */
+function coerceFor(index, value, version) {
+    if (index < 0 || index === 11 || index === 14 || index === 15 || index === 17) {
+        return;
+    }
+    if (index <= 12) {
+        if (value !== undefined && value !== null) {
+            toNumber(value, version);
+        }
+    }
+    else if (index === 13 || index === 19) {
+        stringOf(value, version);
+    }
+    else if (index <= 21) {
+        toNumber(value, version);
+    }
+}
+/** GotoFrame: frame `frame` (0 the first) of the target, which stops. */
+export function gotoFrame(cx, frame) {
+    timelineOf(cx, cx.target)?.goto(frame + 1, false);
+}
+/** GotoLabel: the frame of `label`, if the target has it, which stops. */
+export function gotoLabel(cx, label) {
+    const timeline = timelineOf(cx, cx.target);
+    const frame = timeline?.labelFrame(label);
+    if (frame !== undefined) {
+        timeline?.goto(frame, false);
+    }
+}
+/** GotoFrame2: as `goto` on the target, or the root where there is none, `bias` frames on. */
+export function gotoFrame2(cx, frame, play, bias, version) {
+    const target = targetOrRoot(cx);
+    if (timelineOf(cx, target) !== null) {
+        goto(cx, target, frame, play, bias, version);
+    }
+}
+/** A string as Rust reads an f64: digits with a sign, a point and an exponent, or inf and NaN; null for anything else. */
+function parseNumber(s) {
+    if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) {
+        return Number(s);
+    }
+    if (/^[+-]?(inf|infinity)$/i.test(s)) {
+        return s.startsWith("-") ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+    }
+    return /^[+-]?nan$/i.test(s) ? Number.NaN : null;
+}
+/**
+ * The clip and the frame a goto's or CallFrame's value names from clip
+ * `start`: a whole number its frame; anything else as a string, a path to
+ * a clip and a frame, `/a/b:3` or `a.b.label`, the frame a number or a
+ * label; null where it names none.
+ */
+function frameOf(cx, start, value, version) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return [start, toInt32(value, version)];
+    }
+    const path = stringOf(value, version);
+    let clip = start;
+    let frame = path;
+    const separator = Math.max(path.lastIndexOf(":"), path.lastIndexOf("."));
+    if (separator >= 0) {
+        clip = null;
+        for (let s = cx.scope; s !== null && clip === null; s = s.parent) {
+            const object = targetPath(cx, s.object, path.slice(0, separator), true, true, version);
+            if (object !== null) {
+                clip = cx.host.clipOf?.(object) ?? null;
+                // Not a clip: none, as Ruffle's resolve_variable_path finds an object first.
+                if (clip === null) {
+                    return null;
+                }
+            }
+        }
+        frame = path.slice(separator + 1);
+    }
+    const timeline = clip === null ? null : timelineOf(cx, clip);
+    if (clip === null || timeline === null) {
+        return null;
+    }
+    const n = parseNumber(frame);
+    if (n !== null) {
+        return [clip, toInt32(n, version)];
+    }
+    const labelled = timeline.labelFrame(frame);
+    return labelled === undefined ? null : [clip, labelled];
+}
+/**
+ * A goto of `frame` on clip `target`, gotoAndPlay's and gotoAndStop's and
+ * GotoFrame2's: the frame `frameOf` names, `bias` frames on, if that is
+ * from 1; as a u16, where the timeline clamps it.
+ */
+export function goto(cx, target, frame, play, bias, version) {
+    const found = frameOf(cx, target, frame, version);
+    if (found === null) {
+        return;
+    }
+    const n = Math.min(((found[1] - 1) | 0) + bias + 1, 0x7fffffff);
+    if (n > 0) {
+        timelineOf(cx, found[0])?.goto(Math.max(1, n & 0xffff), play);
+    }
+}
+/** NextFrame: the target's next frame, if it has one, where it stops. */
+export function nextFrame(cx) {
+    const timeline = timelineOf(cx, cx.target);
+    if (timeline !== null && timeline.currentFrame < timeline.totalFrames) {
+        timeline.goto(timeline.currentFrame + 1, false);
+    }
+}
+/** PrevFrame: the target's previous frame, if it has one, where it stops. */
+export function prevFrame(cx) {
+    const timeline = timelineOf(cx, cx.target);
+    if (timeline !== null && timeline.currentFrame > 1) {
+        timeline.goto(timeline.currentFrame - 1, false);
+    }
+}
+/**
+ * WaitForFrame: whether frame `frame` (0 the first) is loaded, which in a
+ * SWF the player has whole every frame is, up to Flash's 16000.
+ */
+export const frameLoaded = (frame) => frame <= 16000;
+/** WaitForFrame2: as WaitForFrame of the value's frame, 1 the first, read as Ruffle reads it. */
+export function frameLoaded2(value, version) {
+    let n = 0;
+    if (typeof value === "number" && Number.isInteger(value)) {
+        n = toInt32(value, version);
+    }
+    else {
+        const parsed = parseNumber(stringOf(value, version));
+        n = parsed !== null && Number.isInteger(parsed) ? toInt32(parsed, version) : 0;
+    }
+    // Less one, wrapping, and one more, saturating.
+    const frame = Math.min(((n - 1) | 0) + 1, 0x7fffffff);
+    return frame <= 16001;
+}
+/** TargetPath: a clip's path, `_level0.a`, undefined for anything else. */
+export function targetPathOf(value) {
+    if (!(value instanceof Avm1Object) || value.display === null) {
+        return undefined;
+    }
+    const live = value.display.live();
+    return live?.display?.path() ?? undefined;
+}
+/** CallFrame: the actions of the frame the value names, on the target or the root, run now. */
+export function callFrame(cx, value, version) {
+    const target = targetOrRoot(cx);
+    const found = typeof value === "number"
+        ? [target, toInt32(value, version) >>> 0]
+        : frameOf(cx, target, value, version);
+    if (found !== null && found[1] <= 0xffff) {
+        timelineOf(cx, found[0])?.call(found[1]);
+    }
+}
+/**
+ * CloneSprite: the display object `source` names from the target, or the
+ * root's where there is none, duplicated as `name` at timeline depth
+ * `depth`, which compilers bias as duplicateMovieClip's own depth is.
+ */
+export function cloneSprite(cx, depth, name, source, version) {
+    const d = toInt32(depth, version);
+    const n = stringOf(name, version);
+    const target = displayOf(cx, targetOrRoot(cx), source, true, version);
+    if (target !== null) {
+        cx.host.duplicate?.(target, n, d);
+    }
+}
+/**
+ * StartDrag, its operands on the stack: the target, whether to lock the
+ * centre, whether to constrain, and if so the bounds' right-to-left
+ * bottom, right, top and left. The display object the target names, from
+ * the code's target or the root, is dragged; an empty one is that target.
+ */
+export function startDrag(cx, version) {
+    const st = cx.st;
+    const value = st.pop();
+    const lockCenter = toBoolean(st.pop(), version);
+    let bounds = null;
+    if (toBoolean(st.pop(), version)) {
+        const bottom = toNumber(st.pop(), version);
+        const right = toNumber(st.pop(), version);
+        const top = toNumber(st.pop(), version);
+        const left = toNumber(st.pop(), version);
+        bounds = [left, top, right, bottom];
+    }
+    const target = displayOf(cx, targetOrRoot(cx), value, true, version);
+    if (target !== null) {
+        cx.host.startDrag?.(target, lockCenter, bounds);
+    }
+}
+/**
+ * RemoveSprite: the display object `value` names from the target, or the
+ * root's, removed; a target it removes gives way to the code's own clip.
+ */
+export function removeSprite(cx, value, version) {
+    const target = displayOf(cx, targetOrRoot(cx), value, true, version);
+    if (target === null) {
+        return;
+    }
+    cx.host.remove?.(target);
+    if (cx.target !== null && cx.host.removed?.(cx.target)) {
+        setTargetClip(cx, cx.base);
+    }
+}

package/dist/thread/runtime/avm1/control.js

@@ -0,0 +1,280 @@
+import { Avm1Throw } from "./errors.js";
+import { Avm1Object } from "./objects.js";
+import { MAX_SCOPES, SCOPE_With, Scope } from "./scope.js";
+/** A With's object, or a catch's variable, on the scope chain. */
+const HELD_Scope = 0;
+const HELD_Try = 1;
+/** A finally reached by a throw: `value` is thrown again as control leaves it. */
+const HELD_Thrown = 2;
+/** A finally reached by a Return, whose value is on the stack: it returns as control leaves it. */
+const HELD_Returned = 3;
+/** A Try's catch that a throw does not land in. */
+const NO_CATCH = -2;
+export class Held {
+    kind;
+    from;
+    to;
+    value;
+    constructor(kind, 
+    /** The blocks it holds over, from `from` to `to`, excluded. */
+    from, to, 
+    /** A finally's thrown value. */
+    value = undefined) {
+        this.kind = kind;
+        this.from = from;
+        this.to = to;
+        this.value = value;
+    }
+    holds(block) {
+        return this.from <= block && block < this.to;
+    }
+    /** Whether a scope holds as control goes to `block`: one of its body's, or the first past it. */
+    admits(block) {
+        return this.from <= block && block <= this.to;
+    }
+}
+const isScope = (h) => h.kind === HELD_Scope;
+/** A scope: the chain it made, and the chain under it, which it gives back as it comes off. */
+class ScopeHeld extends Held {
+    chain;
+    below;
+    constructor(from, to, chain, below) {
+        super(HELD_Scope, from, to);
+        this.chain = chain;
+        this.below = below;
+    }
+}
+/** A Try's handlers, held over its try and catch bodies. */
+class TryHeld extends Held {
+    catchFrom;
+    finallyFrom;
+    finallyTo;
+    catchAt;
+    into;
+    height;
+    constructor(from, 
+    /** Where the catch body starts: before it, a throw is the catch's. */
+    catchFrom, 
+    /** The finally body's blocks, none where it has none. */
+    finallyFrom, finallyTo, 
+    /** Where a throw lands for the catch, -1 for the region's exit, NO_CATCH for none. */
+    catchAt, 
+    /** The catch's variable, or its register. */
+    into, 
+    /** The operand stack's height as the Try ran, which a throw cuts it back to. */
+    height) {
+        super(HELD_Try, from, finallyFrom);
+        this.catchFrom = catchFrom;
+        this.finallyFrom = finallyFrom;
+        this.finallyTo = finallyTo;
+        this.catchAt = catchAt;
+        this.into = into;
+        this.height = height;
+    }
+}
+function heldOf(cx) {
+    let held = cx.held;
+    if (held === null) {
+        held = [];
+        cx.held = held;
+    }
+    return held;
+}
+/** `object` on top of the scope chain, held over the blocks from `from` to `to`. */
+function pushScope(cx, object, from, to) {
+    const below = cx.scope;
+    cx.scope = new Scope(below, SCOPE_With, object);
+    heldOf(cx).push(new ScopeHeld(from, to, cx.scope, below));
+}
+/**
+ * Keeps of `held`, from index `from` up, the entries `keep` says, and the
+ * scope chain as the scopes kept make it: the top one's, or with none
+ * kept, the chain under the first one taken off.
+ */
+function keepFrom(cx, held, from, keep) {
+    let n = from;
+    let top = null;
+    let base = null;
+    for (let i = from; i < held.length; i++) {
+        const h = held[i];
+        if (keep(h)) {
+            held[n++] = h;
+            if (h instanceof ScopeHeld) {
+                top = h.chain;
+            }
+        }
+        else if (h instanceof ScopeHeld && base === null) {
+            base = h.below;
+        }
+    }
+    held.length = n;
+    if (top !== null) {
+        cx.scope = top;
+    }
+    else if (base !== null) {
+        cx.scope = base;
+    }
+}
+/**
+ * Control going to the start of block `at`: the scopes on top that do not
+ * hold there come off at once, as adl looks only at the top one.
+ */
+function reach(cx, held, at) {
+    let n = held.length;
+    while (n > 0 && held[n - 1].kind === HELD_Scope && !held[n - 1].admits(at)) {
+        n--;
+    }
+    if (n < held.length) {
+        keepFrom(cx, held, n, () => false);
+    }
+}
+function cut(st, height) {
+    if (st.length > height) {
+        st.length = height;
+    }
+}
+/**
+ * With: `value`, a primitive boxed, on the scope chain over the body's
+ * blocks; false, the body skipped, for undefined and null, and where the
+ * chain holds MAX_SCOPES already (adl).
+ */
+export function enterWith(cx, value, from, to, version) {
+    if (value === undefined || value === null || cx.scope.depth >= MAX_SCOPES) {
+        return false;
+    }
+    pushScope(cx, cx.realm.box(value, version), from, to);
+    return true;
+}
+/** Try: its handlers, held over its try and catch bodies. */
+export function enterTry(cx, from, catchFrom, finallyFrom, finallyTo, catchAt, into) {
+    heldOf(cx).push(new TryHeld(from, catchFrom, finallyFrom, finallyTo, catchAt, into, cx.st.length));
+}
+/**
+ * Where control goes from the block `at`, where `error` was thrown: the
+ * catch of the first Try whose try body holds it, its variable set, or the
+ * finally of the first whose try or catch body does, which throws the
+ * value again as control leaves it. The stack is cut back to its height
+ * as that Try ran. Another error, a bug's or the host's, a recursion
+ * limit's, passes through, as does a value no Try catches.
+ */
+export function caught(cx, error, at) {
+    const held = cx.held;
+    if (!(error instanceof Avm1Throw) || held === null) {
+        throw error;
+    }
+    cx.into = -1;
+    for (let i = held.length - 1; i >= 0; i--) {
+        const h = held[i];
+        if (!(h instanceof TryHeld) || !h.holds(at)) {
+            continue;
+        }
+        if (at < h.catchFrom && h.catchAt !== NO_CATCH) {
+            // The scopes where it was thrown hold over the catch body too, under
+            // its variable's (adl).
+            const from = h.catchFrom;
+            const to = h.finallyFrom;
+            keepFrom(cx, held, i + 1, isScope);
+            for (let j = i + 1; j < held.length; j++) {
+                held[j].from = from;
+                held[j].to = to;
+            }
+            cut(cx.st, h.height);
+            const into = h.into;
+            if (typeof into === "number") {
+                cx.into = into;
+                cx.thrown = error.value;
+            }
+            else {
+                const scope = new Avm1Object();
+                scope.add(into, error.value, 0);
+                pushScope(cx, scope, from, to);
+            }
+            return h.catchAt;
+        }
+        if (h.finallyFrom < h.finallyTo) {
+            // The finally's mark goes under the scopes, which come off as control goes there.
+            held[i] = new Held(HELD_Thrown, h.finallyFrom, h.finallyTo, error.value);
+            keepFrom(cx, held, i + 1, isScope);
+            cut(cx.st, h.height);
+            reach(cx, held, h.finallyFrom);
+            return h.finallyFrom;
+        }
+    }
+    throw error;
+}
+/**
+ * Control going to block `to` (-1: the exit) across the bounds of a body:
+ * the Trys that do not hold over it come off, and a finally that a throw
+ * or a Return reached throws or returns as control leaves it, even by a
+ * jump. The scopes on top that do not hold there come off; those whose
+ * body it is the first block past, after its first action (V.scopes).
+ */
+export function leave(cx, to) {
+    const held = cx.held;
+    if (held !== null) {
+        for (let i = held.length - 1; i >= 0; i--) {
+            const h = held[i];
+            if (h.holds(to)) {
+                break;
+            }
+            if (h.kind === HELD_Scope) {
+                continue;
+            }
+            held.splice(i, 1);
+            if (h.kind === HELD_Thrown) {
+                throw new Avm1Throw(h.value);
+            }
+            if (h.kind === HELD_Returned) {
+                return returned(cx);
+            }
+        }
+    }
+    if (to < 0) {
+        cx.ret = undefined;
+    }
+    else if (held !== null) {
+        reach(cx, held, to);
+    }
+    return to;
+}
+/** The scopes that do not hold over block `at`, where control is, come off. */
+export function scopes(cx, at) {
+    const held = cx.held;
+    if (held === null) {
+        return;
+    }
+    let n = held.length;
+    while (n > 0 && held[n - 1].kind === HELD_Scope && !held[n - 1].holds(at)) {
+        n--;
+    }
+    if (n < held.length) {
+        keepFrom(cx, held, n, () => false);
+    }
+}
+/**
+ * Return, its value on top of the stack: the finally of the first Try
+ * whose try or catch body holds control runs first, the stack cut back to
+ * its height as that Try ran with the value left on top, and the value is
+ * popped as control leaves it, the stack's top then (adl); a finally's own
+ * throw or Return gives way to this one.
+ */
+export function returned(cx) {
+    const held = cx.held;
+    if (held !== null) {
+        for (let i = held.length - 1; i >= 0; i--) {
+            const h = held[i];
+            if (h instanceof TryHeld && h.finallyFrom < h.finallyTo) {
+                const st = cx.st;
+                const value = st.pop();
+                cut(st, h.height);
+                st.push(value);
+                held[i] = new Held(HELD_Returned, h.finallyFrom, h.finallyTo);
+                keepFrom(cx, held, i + 1, isScope);
+                reach(cx, held, h.finallyFrom);
+                return h.finallyFrom;
+            }
+        }
+    }
+    cx.ret = cx.st.pop();
+    return -1;
+}

package/dist/thread/runtime/avm1/errors.js

@@ -0,0 +1,50 @@
+/** An action the runtime does not do yet: it ends the block it is in. */
+export class NotYet extends Error {
+    name = "Avm1NotYet";
+}
+/**
+ * Thrown once the host has stopped the SWF at an action Flash cannot read,
+ * to end whatever runs; the player takes it for no error.
+ */
+export class Halt extends Error {
+    name = "Avm1Halt";
+}
+/**
+ * Thrown after a call, a `new` or a CallFrame that took the clip whose
+ * code runs off the display list: that code's activation returns there,
+ * a function's with undefined, and the code that called it goes on to its
+ * own check (adl; Ruffle's continue_if_base_clip_exists). One instance,
+ * thrown as a signal and never shown.
+ */
+export class BaseRemoved extends Error {
+    name = "Avm1BaseRemoved";
+}
+export const BASE_REMOVED = new BaseRemoved("the clip whose code runs was removed");
+/**
+ * Thrown past Flash's recursion limit: Flash disables every action of the
+ * movie from there, and its timelines play on.
+ */
+export class Disabled extends Error {
+    name = "Avm1Disabled";
+}
+/**
+ * Thrown as scripts run past the script timeout, Flash's 15 seconds or a
+ * ScriptLimits tag's: Flash asks whether to stop them, and stopped, the
+ * movie's actions are disabled as past the recursion limit (Ruffle halts
+ * its AVM1 so too).
+ */
+export class TimedOut extends Disabled {
+    name = "Avm1TimedOut";
+}
+/**
+ * A value AVM1 code throws (Throw), which a Try's catch or finally takes
+ * and which, caught by none, ends the block as Flash ends it, silently.
+ */
+export class Avm1Throw extends Error {
+    value;
+    name = "Avm1Throw";
+    constructor(value) {
+        super("an AVM1 value thrown and not caught");
+        this.value = value;
+    }
+}