@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/avm1/bindings.js

@@ -0,0 +1,214 @@
+// Text fields bound to AVM1 variables, as Ruffle's (https://github.com/
+// ruffle-rs/ruffle) core/src/display_object/edit_text.rs
+// (try_bind_text_field_variable, propagate_text_binding, set_variable) and
+// display_object.rs (Avm1TextFieldBinding) have them: MIT OR Apache-2.0,
+// Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors. A field's
+// variable is a name, or a path and a name, from the clip the field is in.
+// Where it names a display object's property, the field is bound: a set of
+// the property shows in the field. A field's text set by a script sets the
+// variable, wherever its path leads then. A field whose variable has no
+// object yet waits, and is tried again as a display object is made whose
+// name is a step of its path, the only kind that can give it one.
+import { avm1 } from "../../runtime/index.js";
+import { ButtonObject, CONTENT, MovieClip, TextObject, } from "../display/display.js";
+import { htmlTextOf, setHtmlText, stateOf } from "./globals/TextField.js";
+export class VariableBindings {
+    host;
+    /** The fields bound to each display object's properties, by the property's name. */
+    bound = new WeakMap();
+    /** What each bound field is bound to. */
+    boundTo = new WeakMap();
+    /** How many fields are bound, which a property set looks for none while there are none. */
+    count = 0;
+    /** The fields whose variable's object is not there yet, each with its path's steps in lower case. */
+    waiting = [];
+    /** The fields whose text their variable is taking. */
+    propagating = new Set();
+    constructor(host) {
+        this.host = host;
+    }
+    /** A field made: bound, taking its variable's value, or waiting. */
+    made(field) {
+        if (!this.bind(field, true)) {
+            this.wait(field);
+        }
+    }
+    /** `d` made: the fields waiting with its name a step of their path tried again. */
+    retry(d) {
+        if (this.waiting.length === 0 || d.name === "") {
+            return;
+        }
+        const name = d.name.toLowerCase();
+        this.waiting = this.waiting.filter((waiting) => !waiting.steps.has(name) || !this.bind(waiting.field, false));
+    }
+    /** `field` waiting for its variable's object; not one without a path, whose object is its parent. */
+    wait(field) {
+        const variable = stateOf(field).variable;
+        const separator = variable === null ? -1 : lastSeparator(variable);
+        if (variable === null || separator < 0) {
+            return;
+        }
+        const steps = variable.slice(0, separator).toLowerCase().split(/[.:/]/);
+        this.waiting.push({ field, steps: new Set(steps) });
+    }
+    /**
+     * A field's text changed by a script: the variable takes it, as HTML,
+     * its path resolved again; not again while it is taking it.
+     */
+    textChanged(field) {
+        const variable = stateOf(field).variable;
+        const parent = parentOf(field);
+        if (variable === null || parent === null || this.propagating.has(field)) {
+            return;
+        }
+        this.propagating.add(field);
+        try {
+            this.host.inActivation(parent, (cx) => {
+                const found = variablePath(cx, parent, variable, this.host.version);
+                if (found !== null) {
+                    avm1.set(found[0], found[1], htmlTextOf(field), this.host.version);
+                }
+            });
+        }
+        finally {
+            this.propagating.delete(field);
+        }
+    }
+    /**
+     * A field's variable set: its binding cleared, its text its tag's again,
+     * and bound where it can be now. One that cannot does not wait, as in
+     * Ruffle's set_variable, which leaves it off the unbound list.
+     */
+    variableChanged(field) {
+        this.unbindField(field);
+        field.model.setText(field.definition?.definition?.text ?? "");
+        field.invalidate(CONTENT);
+        field.fit();
+        this.bind(field, true);
+    }
+    /** A property of `d`'s AVM1 object set: the fields bound to it by the name show the value. */
+    propertyChanged(d, name, value, version) {
+        const list = this.count === 0 ? undefined : this.bound.get(d);
+        if (list === undefined) {
+            return;
+        }
+        const key = version > 6 ? name : avm1.fold(name);
+        for (const { field, name: bound } of [...list]) {
+            if ((version > 6 ? bound : avm1.fold(bound)) === key) {
+                setHtmlText(field, avm1.stringOf(value, version));
+            }
+        }
+    }
+    /**
+     * `d` unloaded: a field no longer bound nor waiting, and the fields bound
+     * to `d`'s properties waiting again, for an object at its path.
+     */
+    unloaded(d) {
+        if (d instanceof TextObject) {
+            this.unbindField(d);
+        }
+        const list = this.bound.get(d);
+        if (list !== undefined) {
+            this.bound.delete(d);
+            this.count -= list.length;
+            for (const { field } of list) {
+                this.boundTo.delete(field);
+                this.wait(field);
+            }
+        }
+    }
+    /**
+     * Bind a field to its variable: where `initial`, the field takes the
+     * variable's value, or, where it has none, a field with text gives it
+     * its text. Whether it is bound, which it is only to a display object's
+     * property; a field without a variable is as good as bound.
+     */
+    bind(field, initial) {
+        const variable = stateOf(field).variable;
+        if (variable === null) {
+            return true;
+        }
+        const parent = parentOf(field);
+        if (parent === null) {
+            return false;
+        }
+        let bound = false;
+        const version = this.host.version;
+        this.host.inActivation(parent, (cx) => {
+            const found = variablePath(cx, parent, variable, version);
+            if (found === null) {
+                return;
+            }
+            const [object, name] = found;
+            if (initial) {
+                if (avm1.has(object, name, version)) {
+                    setHtmlText(field, avm1.stringOf(avm1.get(object, name, version), version));
+                }
+                else if (field.model.text !== "") {
+                    avm1.set(object, name, field.model.text, version);
+                }
+            }
+            const target = object.display?.target;
+            if (target !== undefined) {
+                let list = this.bound.get(target);
+                if (list === undefined) {
+                    list = [];
+                    this.bound.set(target, list);
+                }
+                list.push({ field, name });
+                this.count++;
+                this.boundTo.set(field, target);
+                bound = true;
+            }
+        });
+        return bound;
+    }
+    /** A field's binding cleared, and the field no longer waiting for one. */
+    unbindField(field) {
+        const target = this.boundTo.get(field);
+        if (target !== undefined) {
+            this.boundTo.delete(field);
+            const list = this.bound.get(target);
+            if (list !== undefined) {
+                const rest = list.filter((b) => b.field !== field);
+                this.count -= list.length - rest.length;
+                this.bound.set(target, rest);
+            }
+        }
+        const at = this.waiting.findIndex((waiting) => waiting.field === field);
+        if (at >= 0) {
+            this.waiting.splice(at, 1);
+        }
+    }
+}
+/** The clip a field's variable is resolved from: its parent, past any button. */
+function parentOf(field) {
+    let parent = field.parent;
+    while (parent instanceof ButtonObject) {
+        parent = parent.parent;
+    }
+    return parent instanceof MovieClip && parent.avm1 !== null ? parent : null;
+}
+/**
+ * A variable's object and name: a path's object, up to its last `.` or
+ * `:`, resolved along the scope chain, and the name after it; a name
+ * alone is `parent`'s (Ruffle's resolve_variable_path).
+ */
+function variablePath(cx, parent, path, version) {
+    const separator = lastSeparator(path);
+    if (separator < 0) {
+        return parent.avm1 === null ? null : [parent.avm1, path];
+    }
+    const name = path.slice(separator + 1);
+    for (let s = cx.scope; s !== null; s = s.parent) {
+        const object = avm1.targetPath(cx, s.object, path.slice(0, separator), true, true, version);
+        if (object !== null) {
+            return [object, name];
+        }
+    }
+    return null;
+}
+/** Where a variable's last `.` or `:` is, which ends its path; -1 for a name alone. */
+function lastSeparator(variable) {
+    return Math.max(variable.lastIndexOf(":"), variable.lastIndexOf("."));
+}

package/dist/thread/player/avm1/classes.js

@@ -0,0 +1,75 @@
+// Object.registerClass's classes: the constructor a symbol's clips are
+// constructed as, bound by the symbol's export name for every SWF, and
+// the name each was registered by, which SharedObject types objects by.
+import { avm1 } from "../../runtime/index.js";
+import { MovieClip } from "../display/display.js";
+/** A symbol name as registerClass keys it, by a SWF of `version`: in its case from SWF 7. */
+function classKey(name, version) {
+    return version > 6 ? name : avm1.fold(name);
+}
+/** The classes Object.registerClass bound, by symbol name. */
+export class RegisteredClasses {
+    movie;
+    /**
+     * Object.registerClass's classes, by symbol name, one for every SWF:
+     * named in its case from SWF 7, folded up to SWF 6, by the code that
+     * registers and by the SWF of the clip it is looked up for (the
+     * corpus's register_class).
+     */
+    registered = new Map();
+    /**
+     * The name each key was last registered by, in the case it was given,
+     * which AMF0 writes, and when: a constructor of two names is the later's.
+     */
+    spelled = new Map();
+    registrations = 0;
+    constructor(movie) {
+        this.movie = movie;
+    }
+    /**
+     * The class Object.registerClass bound to `d`'s character's export name
+     * in its SWF, null for none.
+     */
+    classOf(d) {
+        // A sprite's only: a button's symbol stays a Button (the corpus's register_class).
+        const id = d instanceof MovieClip ? d.character?.id : undefined;
+        const swf = this.movie.swfOf(d);
+        const name = id === undefined ? undefined : swf.exportNames.get(id);
+        return name === undefined ? null : (this.registered.get(classKey(name, swf.version)) ?? null);
+    }
+    /** The name Object.registerClass gave `constr`, as SharedObject's AMF0 types an object; null for none. */
+    registeredName(constr) {
+        if (!(constr instanceof avm1.Avm1Function)) {
+            return null;
+        }
+        let found = null;
+        for (const [key, registered] of this.registered) {
+            const spelled = this.spelled.get(key) ?? { name: key, at: -1 };
+            if (registered === constr && (found === null || spelled.at > found.at)) {
+                found = spelled;
+            }
+        }
+        return found?.name ?? null;
+    }
+    /** Object.registerClass(name, constructor): true where it binds or unbinds (null) the name. */
+    registerClass(args, version) {
+        if (args.length < 2) {
+            return false;
+        }
+        const constr = args[1];
+        if (constr !== undefined && constr !== null && !(constr instanceof avm1.Avm1Function)) {
+            return false;
+        }
+        const name = avm1.stringOf(args[0], version);
+        const key = classKey(name, version);
+        if (constr instanceof avm1.Avm1Function) {
+            this.registered.set(key, constr);
+            this.spelled.set(key, { name, at: this.registrations++ });
+        }
+        else {
+            this.registered.delete(key);
+            this.spelled.delete(key);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,229 @@
+// The display objects an AVM1 movie's scripts make and take away:
+// attachMovie's, createEmptyMovieClip's, createTextField's and
+// duplicateMovieClip's, each placed and made at once, constructed as its
+// registered class with its init object's properties, and removeMovieClip's
+// removal of what is at a depth scripts place at.
+// The depths and the order of construction follow Ruffle's
+// (https://github.com/ruffle-rs/ruffle) construct_as_avm1_object: MIT OR
+// Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and Ruffle contributors.
+import { ClipEvent } from "../../format/index.js";
+import { avm1 } from "../../runtime/index.js";
+import { Container, construct, displayFor, EMPTY_TIMELINE, MovieClip, TextObject, } from "../display/display.js";
+import { ClipNative, DEPTH_BIAS, nativeOf } from "./globals/MovieClip.js";
+import { asciiLower } from "./paths.js";
+import { BLOCK, CONSTRUCT, NO_ARGS, Queued } from "./queue.js";
+import { NO_HANDLERS } from "./swf.js";
+/** The highest timeline depth scripts place at, 2^31 - 16777220, as Ruffle has it. */
+const MAX_DEPTH = 2130706428;
+/** The depth from which removeMovieClip removes nothing. */
+const MAX_REMOVE_DEPTH = 2130706416;
+/** The blocks of a clip's construct events. */
+export function constructBlocks(native) {
+    const blocks = [];
+    for (const h of native.handlers ?? NO_HANDLERS) {
+        if (h.events & ClipEvent.construct) {
+            blocks.push(h.block);
+        }
+    }
+    return blocks;
+}
+/** Whether a character is one a timeline places. */
+function isDisplayCharacter(c) {
+    const type = c?.type;
+    return (type === "sprite" ||
+        type === "shape" ||
+        type === "morph" ||
+        type === "button" ||
+        type === "text" ||
+        type === "static" ||
+        type === "bitmap");
+}
+/** What the movie's scripts place on and take off the display list. */
+export class ScriptClips {
+    movie;
+    /** The display object a script is making, which it constructs itself; its children are the timeline's. */
+    scripted = null;
+    constructor(movie) {
+        this.movie = movie;
+    }
+    /**
+     * attachMovie: the character exported as `name` placed in `parent` at
+     * AVM1 depth `depth` as `instance`, made as a script makes one; null
+     * where there is no such character or the depth is out of range.
+     */
+    attachMovie(parent, name, instance, depth, init) {
+        const timelineDepth = (depth + DEPTH_BIAS) | 0;
+        if (timelineDepth < 0 || timelineDepth > MAX_DEPTH) {
+            return null;
+        }
+        const swf = this.movie.swfOf(parent);
+        const id = swf.exports.get(asciiLower(name));
+        const character = id === undefined ? undefined : swf.library?.characters.get(id);
+        if (!isDisplayCharacter(character)) {
+            return null;
+        }
+        const child = displayFor(character, parent.library);
+        return this.scriptPlace(parent, child, character, instance, timelineDepth, init);
+    }
+    /** createEmptyMovieClip: an empty clip in `parent` at AVM1 depth `depth` as `instance`. */
+    createEmptyMovieClip(parent, instance, depth) {
+        const child = new MovieClip(EMPTY_TIMELINE, parent.library);
+        return this.scriptPlace(parent, child, null, instance, (depth + DEPTH_BIAS) | 0, null);
+    }
+    /** createTextField: an empty field in `parent` at AVM1 depth `depth` as `instance`. */
+    createTextField(parent, instance, depth, [x, y, width, height]) {
+        const field = new TextObject(null);
+        field.fonts = parent.library.fonts;
+        field.width = width;
+        field.height = height;
+        field.matrix = { ...field.matrix, tx: x, ty: y };
+        return this.scriptPlace(parent, field, null, instance, (depth + DEPTH_BIAS) | 0, null);
+    }
+    /**
+     * duplicateMovieClip and CloneSprite: a new one of `d`'s character, or an
+     * empty clip for a script's, beside it at timeline depth `depth` as
+     * `name`, with its matrix, colour and clip actions; null where `d` has
+     * no clip for a parent or the depth is out of range.
+     */
+    duplicate(d, name, depth, init) {
+        const parent = this.movie.levelOf(d) !== null ? null : d.parent;
+        if (!(parent instanceof MovieClip) || this.movie.removed(d) || depth < 0 || depth > MAX_DEPTH) {
+            return null;
+        }
+        const character = d.character;
+        let child;
+        if (isDisplayCharacter(character)) {
+            child = displayFor(character, parent.library);
+        }
+        else if (d instanceof MovieClip) {
+            child = new MovieClip(EMPTY_TIMELINE, parent.library);
+        }
+        else {
+            return null;
+        }
+        child.matrix = { ...d.matrix };
+        child.colorTransform = d.colorTransform === null ? null : { ...d.colorTransform };
+        const native = nativeOf(d);
+        if (native !== null && native.handlers !== null) {
+            this.handed.set(child, native);
+        }
+        return this.scriptPlace(parent, child, isDisplayCharacter(character) ? character : null, name, depth, init);
+    }
+    /** The clips a duplicate takes the clip actions of, until it is made. */
+    handed = new WeakMap();
+    /**
+     * removeMovieClip and RemoveSprite: `d` removed, where it is at a depth
+     * scripts place at (a timeline's clip swapped there too), as Flash
+     * removes only those.
+     */
+    remove(d) {
+        const parent = this.movie.levelOf(d) !== null ? null : d.parent;
+        const depth = d.depth;
+        if (!(parent instanceof Container) ||
+            depth === null ||
+            depth < DEPTH_BIAS ||
+            depth >= MAX_REMOVE_DEPTH ||
+            this.movie.removed(d)) {
+            return;
+        }
+        parent.removeAtDepth(depth);
+    }
+    /**
+     * A display object a script made, put in `parent` at timeline depth
+     * `depth` as `name` and made: its first frame entered, its children
+     * placed, its load queued; then its construct events, its init
+     * object's properties, before them up to SWF 6, its class's constructor
+     * and its onConstruct at once, its initialize events queued as it was
+     * made (adl:
+     * Ruffle runs neither event, and onConstruct only for
+     * createEmptyMovieClip's).
+     */
+    scriptPlace(parent, child, character, name, depth, init) {
+        child.name = name;
+        parent.placeAtDepth(child, depth);
+        const outer = this.scripted;
+        this.scripted = child;
+        try {
+            if (character !== null) {
+                construct(child, character, parent.library);
+            }
+            else {
+                this.movie.made(child);
+                if (child instanceof MovieClip) {
+                    child.enterFirstFrame();
+                }
+            }
+        }
+        finally {
+            this.scripted = outer;
+        }
+        const face = child.avm1;
+        const native = face?.display;
+        if (face === null || !(native instanceof ClipNative)) {
+            return child;
+        }
+        const version = this.movie.swfOf(child).version;
+        const constr = this.movie.classes.classOf(child);
+        if (constr !== null) {
+            face.define("__proto__", avm1.get(constr, "prototype", version), avm1.DONT_ENUM | avm1.DONT_DELETE);
+        }
+        // It is constructed as the queue's constructions are: a function returning in it
+        // runs only initializations queued (the corpus's register_and_init_order).
+        const pass = this.movie.queue.priority;
+        this.movie.queue.priority = CONSTRUCT;
+        try {
+            // A SWF 6 sets the init object's properties before the construct events, a later one
+            // after (adl).
+            if (version <= 6) {
+                this.initProperties(face, init, version);
+            }
+            for (const block of constructBlocks(native)) {
+                this.movie.queue.runOne(new Queued(BLOCK, child, native.swf, block), []);
+            }
+            if (version > 6) {
+                this.initProperties(face, init, version);
+            }
+            if (constr !== null) {
+                this.construct(child, face, constr);
+            }
+            // Then its onConstruct, from MovieClip's prototype or its class's, what it
+            // throws caught there (adl, and the corpus's movieclip_onconstruct).
+            const cx = this.movie.activationOf(child);
+            if (cx !== null) {
+                this.movie.rt.callMethod(cx, face, "onConstruct", NO_ARGS, version);
+            }
+        }
+        finally {
+            this.movie.queue.priority = pass;
+        }
+        return child;
+    }
+    /** An init object's properties set on `face`, in the reverse of for..in's order, as Flash sets them. */
+    initProperties(face, init, version) {
+        const cx = init === null ? null : this.movie.activationOf(this.movie.root);
+        if (init === null || cx === null) {
+            return;
+        }
+        this.movie.rt.call(cx, () => {
+            const names = avm1.keys(init, version);
+            for (let i = names.length - 1; i >= 0; i--) {
+                avm1.set(face, names[i], avm1.get(init, names[i], version), version);
+            }
+        });
+    }
+    /** `constr` run on the clip's object as its constructor, as `new` runs one. */
+    construct(clip, face, constr) {
+        const cx = this.movie.activationOf(clip);
+        if (cx === null) {
+            return;
+        }
+        const version = this.movie.swfOf(clip).version;
+        face.define("__constructor__", constr, avm1.DONT_ENUM);
+        if (version < 7) {
+            face.define("constructor", constr, avm1.DONT_ENUM);
+        }
+        this.movie.rt.call(cx, () => {
+            constr.callConstructor(face, NO_ARGS, version, 1);
+        });
+    }
+}

package/dist/thread/player/avm1/compile.js

@@ -0,0 +1,140 @@
+import { avm1 } from "../../runtime/index.js";
+import { evaluateFunction } from "../scripting/evaluate.js";
+let scripts = 0;
+/**
+ * Stable region arrays let the runtime and ExternalInterface identify a
+ * block before it is compiled; its functions keep that same array after.
+ */
+export function lazyBlocks(codegen, bytes, actions, rt) {
+    const script = ++scripts;
+    const version = actions.version;
+    const evaluate = (entry, name) => {
+        // AVM1 identifies its callers by region arrays, including on engines
+        // whose Function stack frames do not name their sourceURL.
+        const source = `export default function (rt) {\nconst V = rt.version(${version});\n${version < 5 ? "const V5 = rt.version(5);\n" : ""}return [\n${entry}\n];\n}\n`;
+        const factory = evaluateFunction(source, `swf2es-avm1-${script}-${name}.js`);
+        return factory(rt)[0];
+    };
+    const blocks = actions.blocks.map((_, index) => {
+        const regions = [];
+        regions.push((cx) => {
+            const entry = codegen.compileActionBlocks(bytes, actions, [index]).get(index);
+            if (entry === undefined) {
+                throw new Error(`swf2es: no compiled AVM1 block ${index}`);
+            }
+            const compiled = evaluate(entry, `${index}`);
+            regions.length = 0;
+            for (const region of compiled) {
+                regions.push(region);
+            }
+            return regions[0](cx);
+        });
+        return regions;
+    });
+    const units = unitsOf(codegen, bytes, actions, blocks, rt.realm.units, evaluate);
+    for (const regions of blocks) {
+        rt.realm.units.set(regions, units);
+    }
+    return blocks;
+}
+/**
+ * A SWF's units, each compiled as control first goes on in it: first the
+ * one of a region and bytes that end at the next bound of a block, which
+ * most regions can run, else the region's own (codegen's module.ts).
+ */
+function unitsOf(codegen, bytes, actions, blocks, known, evaluate) {
+    const bounds = blockBounds(bytes.length, actions);
+    // By offset, twice and once more for SWF 5's functions; by key, those of a region alone.
+    const first = new Map();
+    const own = new avm1.OwnUnits();
+    // Units of the same code are one, as the module writes them once: by
+    // the code's hash and length, the code itself not kept.
+    const byCode = new Map();
+    const units = {
+        blocks,
+        unit(at, end, bound, five) {
+            const index = at * 2 + (five ? 1 : 0);
+            let unit = first.get(index);
+            if (unit === undefined) {
+                const segment = segmentEnd(bounds, bytes.length, at);
+                const compiled = codegen.compileActionUnit(bytes, actions, {
+                    at,
+                    end: segment,
+                    bound: segment,
+                    five,
+                });
+                // One that only its own region runs never runs as a first choice.
+                unit = { ...compiled, code: compiled.high >= 0 ? compiled.code : null, regions: null };
+                first.set(index, unit);
+            }
+            if (unit.high >= 0 && unit.high <= end && unit.reach <= bound) {
+                if (unit.regions === null) {
+                    unit.regions = regionsOf(unit.code ?? "", at);
+                    unit.code = null;
+                }
+                return unit.regions;
+            }
+            let regions = own.get(at, end, bound, five);
+            if (regions === undefined) {
+                const { code } = codegen.compileActionUnit(bytes, actions, { at, end, bound, five });
+                regions = regionsOf(code, at);
+                own.set(at, end, bound, five, regions);
+            }
+            return regions;
+        },
+    };
+    const regionsOf = (code, at) => {
+        const hash = hashOf(code);
+        const same = byCode.get(hash);
+        for (const regions of same ?? []) {
+            // The regions' source is the code they were made of.
+            if (`[${regions.join(", ")}]` === code) {
+                return regions;
+            }
+        }
+        const regions = evaluate(code, `at-${at}`);
+        known.set(regions, units);
+        if (same === undefined) {
+            byCode.set(hash, [regions]);
+        }
+        else {
+            same.push(regions);
+        }
+        return regions;
+    };
+    return units;
+}
+/** FNV-1a of `text`'s code units, and its length. */
+function hashOf(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193);
+    }
+    return (hash >>> 0) * 0x100000 + (text.length & 0xfffff);
+}
+/** The starts and ends of the SWF's blocks within its bytes, ascending, once each. */
+function blockBounds(size, actions) {
+    const bounds = new Set();
+    for (const { offset, length } of actions.blocks) {
+        if (offset >= 0 && length >= 0 && offset + length <= size) {
+            bounds.add(offset);
+            bounds.add(offset + length);
+        }
+    }
+    return [...bounds].sort((a, b) => a - b);
+}
+/** The first of `bounds` past `at`, else the SWF's end, as codegen's units.ts finds it. */
+function segmentEnd(bounds, size, at) {
+    let low = 0;
+    let high = bounds.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (bounds[mid] <= at) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low < bounds.length ? bounds[low] : size;
+}