@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm2/natives/sort.js

@@ -0,0 +1,377 @@
+// Array's and Vector's sort and sortOn, as avmplus' ArraySort does them:
+// its own quicksort, not stable, so that elements that compare equal end
+// up in the order avmplus leaves them; undefined elements after the
+// others, and missing ones last; and its options and comparisons, with the
+// bug compatibility of the latest SWF version (bugzillas 524122, 532454).
+//
+// Translated from avmplus' core/ArrayClass.cpp, this file is subject to the
+// Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+import { FloatValue } from "../float.js";
+import { publicQname } from "../names.js";
+import { SEALED_ELEMENTS } from "../runtime.js";
+import { lowerCase } from "./case.js";
+import { getElement, isObject, lengthOf } from "./define.js";
+import { FloatVector } from "./float-vector.js";
+const kCaseInsensitive = 1;
+const kDescending = 2;
+const kUniqueSort = 4;
+const kReturnIndexedArray = 8;
+const kNumeric = 16;
+function stringCompare(rt, lower) {
+    return (x, y) => {
+        let a = rt.toString(x);
+        let b = rt.toString(y);
+        if (lower) {
+            a = lowerCase(a);
+            b = lowerCase(b);
+        }
+        return a < b ? -1 : a > b ? 1 : 0;
+    };
+}
+function numericCompare(rt) {
+    return (x, y) => {
+        const a = rt.toNumber(x);
+        const b = rt.toNumber(y);
+        const diff = a - b;
+        if (!Number.isNaN(diff)) {
+            return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+        }
+        return !Number.isNaN(b) ? 1 : !Number.isNaN(a) ? -1 : 0;
+    };
+}
+/** The comparison options name, without a compare function. */
+function compareOf(rt, options) {
+    const compare = options & kNumeric ? numericCompare(rt) : stringCompare(rt, (options & kCaseInsensitive) !== 0);
+    return options & kDescending ? (x, y) => compare(y, x) : compare;
+}
+/** As ArrayClass::generic_sort: sort(), sort(compare), sort(options) or sort(compare, options). */
+export function sort(rt, d, args) {
+    if (!isObject(d)) {
+        return undefined;
+    }
+    let compare = null;
+    let options = 0;
+    let numeric = false;
+    if (args.length >= 1) {
+        const arg0 = args[0];
+        if (isObject(arg0)) {
+            if (!arg0.$f) {
+                throw rt.error("TypeError", 1034, rt.describe(arg0), "Function");
+            }
+            // The comparator's result counts by its sign, as a Number. Its arguments go in one pair for
+            // the sort, not one a comparison: the comparator has $f, which callValue calls with apply,
+            // and apply copies the pair into the call's own parameters, rest or arguments, a native's
+            // as an AS3 method's, keeping no reference to it. A comparator that sorts inside itself has
+            // its own sort's pair.
+            const pair = [undefined, undefined];
+            compare = (x, y) => {
+                pair[0] = x;
+                pair[1] = y;
+                const result = rt.toNumber(rt.callValue(arg0, d, pair, null));
+                return result > 0 ? 1 : result < 0 ? -1 : 0;
+            };
+            if (args.length >= 2) {
+                if (typeof args[1] !== "number" && !(args[1] instanceof FloatValue)) {
+                    throw rt.error("TypeError", 1034, rt.describe(args[1]), "Number");
+                }
+                options = rt.toInt(args[1]);
+            }
+        }
+        else if (typeof arg0 === "number" || arg0 instanceof FloatValue) {
+            options = rt.toInt(arg0);
+        }
+        else {
+            throw rt.error("TypeError", 1034, rt.describe(arg0), "Function");
+        }
+    }
+    if (compare === null) {
+        numeric = (options & kNumeric) !== 0;
+        compare = compareOf(rt, options);
+    }
+    else if (options & kDescending) {
+        const ascending = compare;
+        compare = (x, y) => ascending(y, x);
+    }
+    return sortWith(rt, d, options, compare, numeric, null);
+}
+/** As ArrayClass::generic_sortOn: by one field or several, each with its options. */
+export function sortOn(rt, d, names, optionsIn) {
+    if (!isObject(d)) {
+        return undefined;
+    }
+    const fields = [];
+    let options = 0;
+    if (typeof names === "string") {
+        options = rt.toInt(optionsIn);
+        fields.push({ name: names, options });
+    }
+    else if (names?.$a && names.$traits.name === "Array") {
+        for (const n of names.$a) {
+            fields.push({ name: rt.toString(n), options: 0 });
+        }
+        if (optionsIn?.$a && optionsIn.$traits.name === "Array") {
+            const list = optionsIn.$a;
+            if (list.length === fields.length) {
+                options = rt.toInt(list[0]);
+                fields.forEach((f, i) => {
+                    f.options = rt.toInt(list[i]);
+                });
+            }
+        }
+        else {
+            options = rt.toInt(optionsIn);
+            for (const f of fields) {
+                f.options = options;
+            }
+        }
+    }
+    // One field sorts by its values (sortWith), which needs no comparison of the elements.
+    const compare = fields.length === 1 ? unused : fieldCompare(rt, fields, options);
+    return sortWith(rt, d, options, compare, false, fields);
+}
+/** No comparison: sortWith makes its own where it is given this. */
+const unused = () => 0;
+/** As ArraySort::FieldCompare: by each field in turn, until one differs. */
+function fieldCompare(rt, fields, options) {
+    // Each field's name and comparison made once for the sort, not for each comparison.
+    const names = fields.map((field) => publicQname(field.name, rt.userVersions));
+    const compares = fields.map((field) => field.options & kNumeric
+        ? numericCompare(rt)
+        : stringCompare(rt, (field.options & kCaseInsensitive) !== 0));
+    return (j, k) => {
+        let opt = options;
+        let result = 0;
+        const objJ = isObject(j) ? j : null;
+        const objK = isObject(k) ? k : null;
+        if (!(objJ && objK)) {
+            result = objK ? 1 : objJ ? -1 : 0;
+            return opt & kDescending ? -result : result;
+        }
+        for (let f = 0; f < fields.length; f++) {
+            const name = names[f];
+            opt = fields[f].options;
+            const x = rt.getProperty(objJ, name);
+            const y = rt.getProperty(objK, name);
+            const defX = x !== undefined;
+            const defY = y !== undefined;
+            if (!(defX && defY)) {
+                if (defY) {
+                    result = 1;
+                }
+                else if (defX) {
+                    result = -1;
+                }
+                else {
+                    const hasX = rt.hasProperty(objJ, name);
+                    const hasY = rt.hasProperty(objK, name);
+                    result = !hasX && hasY ? 1 : hasX && !hasY ? -1 : 0;
+                }
+            }
+            else {
+                result = compares[f](x, y);
+            }
+            if (result !== 0) {
+                break;
+            }
+        }
+        return opt & kDescending ? -result : result;
+    };
+}
+/**
+ * As ArraySort's constructor: split the elements into defined, undefined
+ * and missing ones, quicksort the defined, then write them back, or
+ * return their order.
+ */
+function sortWith(rt, d, options, compareIn, numeric, fields) {
+    // The length as getLengthProperty reads it: an Array subclass may
+    // override its getter. An Array's or a Vector's elements are in their
+    // storage; anything else's are its properties.
+    const len = lengthOf(rt, d);
+    const storage = d.$a;
+    const a = storage !== undefined && storage !== SEALED_ELEMENTS ? storage : null;
+    // As ArraySort, which leaves what it cannot index unsorted.
+    if (len === 0 || len >= 0x10000000) {
+        return d;
+    }
+    const index = new Array(len);
+    const atoms = new Array(len);
+    let fieldAtoms = null;
+    let compare = compareIn;
+    let j = len;
+    let newlen = len;
+    // An element that sorts after the others: undefined ones next, then missing ones.
+    const partition = (i) => {
+        j--;
+        const temp = index[i];
+        index[i] = index[j];
+        // As hasUintProperty: a Proxy is asked through its hasProperty.
+        if (!(a !== null ? i in a : rt.in(i, d))) {
+            newlen--;
+            index[j] = index[newlen];
+            index[newlen] = temp;
+        }
+        else {
+            index[j] = temp;
+        }
+    };
+    if (fields && fields.length === 1) {
+        // One field: sort by its values, then write back the elements.
+        fieldAtoms = new Array(len);
+        const name = publicQname(fields[0].name, rt.userVersions);
+        for (let i = len - 1; i >= 0; i--) {
+            index[i] = i;
+            const v = getElement(rt, d, i);
+            fieldAtoms[i] = v;
+            if (isObject(v)) {
+                atoms[i] = rt.getProperty(v, name);
+            }
+            else {
+                partition(i);
+            }
+        }
+        compare = compareOf(rt, fields[0].options);
+    }
+    else {
+        for (let i = len - 1; i >= 0; i--) {
+            index[i] = i;
+            // As getUintProperty: a hole finds the prototype's element.
+            atoms[i] = getElement(rt, d, i);
+            if (numeric &&
+                typeof atoms[i] !== "number" &&
+                !(atoms[i] instanceof FloatValue) &&
+                Number.isNaN(rt.toNumber(atoms[i]))) {
+                throw rt.error("TypeError", 1034, rt.describe(atoms[i]), "Number");
+            }
+            if (atoms[i] === undefined) {
+                partition(i);
+            }
+        }
+    }
+    const cmp = (l, r) => compare(atoms[index[l]], atoms[index[r]]);
+    const swap = (l, r) => {
+        const t = index[l];
+        index[l] = index[r];
+        index[r] = t;
+    };
+    if (j > 1) {
+        qsort(0, j - 1, cmp, swap);
+    }
+    if (options & kUniqueSort) {
+        for (let i = 0; i < len - 1; i++) {
+            if (cmp(i, i + 1) === 0) {
+                return 0;
+            }
+        }
+    }
+    if (options & kReturnIndexedArray) {
+        return rt.array(index.slice());
+    }
+    // Into the elements as they are now: a comparison may have set a
+    // Vector's length, which gives it a new array. Read through the order from
+    // the sort's own copy of them.
+    const source = fieldAtoms ?? atoms;
+    const target = d.$a;
+    if (target === undefined || target === SEALED_ELEMENTS) {
+        // As setUintProperty and delUintProperty: the length is left as it is.
+        for (let i = 0; i < newlen; i++) {
+            rt.setProperty(d, rt.publicName(i), source[index[i]]);
+        }
+        for (let i = newlen; i < len; i++) {
+            rt.deleteProperty(d, rt.publicName(i));
+        }
+        return d;
+    }
+    if (target instanceof FloatVector) {
+        if (target.length < newlen) {
+            target.length = newlen;
+        }
+        for (let i = 0; i < newlen; i++) {
+            target.data[i] = rt.toNumber(source[index[i]]);
+        }
+        return d;
+    }
+    for (let i = 0; i < newlen; i++) {
+        target[i] = source[index[i]];
+    }
+    for (let i = newlen; i < len; i++) {
+        delete target[i];
+    }
+    return d;
+}
+/** As ArraySort::qsort: iterative, the middle element as pivot, the smaller partition first. */
+function qsort(loIn, hiIn, compare, swap) {
+    let lo = loIn;
+    let hi = hiIn;
+    // Each frame's lo and hi, flat: a pair for each was garbage of the sort.
+    const stack = [];
+    if (lo >= hi) {
+        return;
+    }
+    for (;;) {
+        const size = hi - lo + 1;
+        if (size < 4) {
+            if (size === 3) {
+                if (compare(lo, lo + 1) > 0) {
+                    swap(lo, lo + 1);
+                    if (compare(lo + 1, lo + 2) > 0) {
+                        swap(lo + 1, lo + 2);
+                        if (compare(lo, lo + 1) > 0) {
+                            swap(lo, lo + 1);
+                        }
+                    }
+                }
+                else if (compare(lo + 1, lo + 2) > 0) {
+                    swap(lo + 1, lo + 2);
+                    if (compare(lo, lo + 1) > 0) {
+                        swap(lo, lo + 1);
+                    }
+                }
+            }
+            else if (size === 2 && compare(lo, lo + 1) > 0) {
+                swap(lo, lo + 1);
+            }
+        }
+        else {
+            swap(lo + Math.floor(size / 2), lo);
+            let left = lo;
+            let right = hi + 1;
+            for (;;) {
+                do {
+                    left++;
+                } while (left <= hi && compare(left, lo) <= 0);
+                do {
+                    right--;
+                } while (right > lo && compare(right, lo) >= 0);
+                if (right < left) {
+                    break;
+                }
+                swap(left, right);
+            }
+            swap(lo, right);
+            // Unsigned in avmplus: right - 1 - lo wraps when right is lo.
+            if ((right - 1 - lo) >>> 0 >= (hi - left) >>> 0) {
+                if (lo + 1 < right) {
+                    stack.push(lo, right - 1);
+                }
+                if (left < hi) {
+                    lo = left;
+                    continue;
+                }
+            }
+            else {
+                if (left < hi) {
+                    stack.push(left, hi);
+                }
+                if (lo + 1 < right) {
+                    hi = right - 1;
+                    continue;
+                }
+            }
+        }
+        if (stack.length === 0) {
+            return;
+        }
+        hi = stack.pop();
+        lo = stack.pop();
+    }
+}

package/dist/thread/runtime/avm2/natives/string.js

@@ -0,0 +1,132 @@
+// String: `this` is the string.
+import { lowerCase, upperCase } from "./case.js";
+import { AS3, conversion, plain } from "./define.js";
+import { compile, matchArray, replacement as replacementOf } from "./regexp.js";
+/** Flash resolves a negative end (start + length) from the string's end. */
+function substr(s, start, length) {
+    if (!(length < 0)) {
+        return s.substr(start, length);
+    }
+    const offset = Math.trunc(start) || 0;
+    const at = offset < 0 ? Math.max(0, s.length + offset) : Math.min(offset, s.length);
+    const end = at + Math.trunc(length);
+    return end < 0 ? s.slice(at, end) : "";
+}
+export const stringNatives = {
+    "String#get:length": plain(function () {
+        return this.length;
+    }),
+    [`String.${AS3}::fromCharCode`]: (rt) => (...codes) => {
+        return String.fromCharCode(...codes.map((c) => rt.toUint(c) & 0xffff));
+    },
+    [`String#${AS3}::charAt`]: (rt) => function (i = 0) {
+        return this.charAt(rt.toNumber(i));
+    },
+    [`String#${AS3}::charCodeAt`]: (rt) => function (i = 0) {
+        return this.charCodeAt(rt.toNumber(i));
+    },
+    [`String#${AS3}::indexOf`]: (rt) => function (s = "undefined", i = 0) {
+        return this.indexOf(rt.toString(s), rt.toNumber(i));
+    },
+    [`String#${AS3}::lastIndexOf`]: (rt) => function (s = "undefined", i = 0x7fffffff) {
+        // As String::lastIndexOf, from INTCLAMP: from before the start nothing matches.
+        const at = rt.toNumber(i);
+        return at <= -1 ? -1 : this.lastIndexOf(rt.toString(s), at);
+    },
+    [`String#${AS3}::localeCompare`]: (rt) => function (other) {
+        // As String::Compare: the first difference of their character codes,
+        // else which is longer.
+        const o = rt.toString(other);
+        const n = Math.min(this.length, o.length);
+        for (let i = 0; i < n; i++) {
+            const d = this.charCodeAt(i) - o.charCodeAt(i);
+            if (d) {
+                return d;
+            }
+        }
+        return Math.sign(this.length - o.length);
+    },
+    [`String#${AS3}::slice`]: (rt) => function (start = 0, end = 0x7fffffff) {
+        return this.slice(rt.toNumber(start), rt.toNumber(end));
+    },
+    [`String#${AS3}::substring`]: (rt) => function (start = 0, end = 0x7fffffff) {
+        return this.substring(rt.toNumber(start), rt.toNumber(end));
+    },
+    [`String#${AS3}::substr`]: (rt) => function (start = 0, length = 0x7fffffff) {
+        return substr(this, rt.toNumber(start), rt.toNumber(length));
+    },
+    [`String#${AS3}::toLowerCase`]: plain(function () {
+        return lowerCase(this);
+    }),
+    [`String#${AS3}::toUpperCase`]: plain(function () {
+        return upperCase(this);
+    }),
+    "String#String::_indexOf": plain(function (s, i = 0) {
+        return this.indexOf(s, i);
+    }),
+    "String#String::_lastIndexOf": plain(function (s, i = 0x7fffffff) {
+        return i < 0 ? -1 : this.lastIndexOf(s, i);
+    }),
+    "String#String::_slice": plain(function (start = 0, end = 0x7fffffff) {
+        return this.slice(start, end);
+    }),
+    "String#String::_substring": plain(function (start = 0, end = 0x7fffffff) {
+        return this.substring(start, end);
+    }),
+    "String#String::_substr": plain(function (start = 0, length = 0x7fffffff) {
+        return substr(this, start, length);
+    }),
+    "String.String::_replace": (rt) => (s, pattern, replacement) => {
+        const p = pattern?.$re instanceof RegExp ? pattern.$re : rt.toString(pattern);
+        if (replacement !== null && typeof replacement === "object" && replacement.$f) {
+            // The function gets the match, its groups, its position and the string.
+            return s.replace(p, (...a) => {
+                const args = typeof a[a.length - 1] === "object" ? a.slice(0, -1) : a;
+                return rt.toString(rt.callValue(replacement, null, args, null));
+            });
+        }
+        const text = rt.toString(replacement);
+        return s.replace(p, p instanceof RegExp ? replacementOf(p, text) : text);
+    },
+    // A string pattern is a RegExp's, as avmplus makes one of it.
+    "String.String::_search": (rt) => (s, pattern) => s.search(pattern?.$re instanceof RegExp ? pattern.$re : compile(rt.toString(pattern), "")),
+    "String.String::_match": (rt) => (s, pattern) => {
+        const re = pattern?.$re instanceof RegExp ? pattern.$re : compile(rt.toString(pattern), "");
+        if (!re.global) {
+            const m = s.match(re);
+            return m ? matchArray(rt, m) : null;
+        }
+        // As RegExpObject::match: each match from where the last ended, until
+        // one fails or is empty, so none is an empty Array; lastIndex is then
+        // where the last try ended, 0 for a failed one, one on if it was there.
+        const old = re.lastIndex;
+        const found = [];
+        let at = 0;
+        for (;;) {
+            re.lastIndex = at;
+            const m = re.exec(s);
+            const last = at;
+            at = m ? m.index + m[0].length : 0;
+            if (!m || at === last) {
+                break;
+            }
+            found.push(m[0]);
+        }
+        re.lastIndex = at === old ? at + 1 : at;
+        return rt.array(found);
+    },
+    "String.String::_split": (rt) => (s, delimiter, limit) => {
+        // The empty string splits to itself, whatever the delimiter, as avmplus has it.
+        if (s === "") {
+            return rt.array(limit === 0 ? [] : [""]);
+        }
+        if (delimiter?.$re instanceof RegExp) {
+            return rt.array(s.split(delimiter.$re, limit >= 0 ? limit : undefined));
+        }
+        const parts = s.split(rt.toString(delimiter));
+        return rt.array(limit >= 0 && limit < parts.length ? parts.slice(0, limit) : parts);
+    },
+};
+export const stringHooks = {
+    String: conversion((rt, args) => (args.length ? rt.toString(args[0]) : "")),
+};