@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/globalization/NumberFormatter.js

@@ -0,0 +1,444 @@
+// flash.globalization.NumberFormatter, and the number formatting and
+// parsing it shares with CurrencyFormatter. Flash on Windows formats with
+// its own rules from the locale's settings, which a script may change one
+// by one, so only those settings come from Intl: the digits, separators and
+// patterns are applied here as Flash applies them.
+import { avm2 } from "../../../../runtime/index.js";
+import { availableLocales, ILLEGAL_ARGUMENT_ERROR, INVALID_ATTR_VALUE, NO_ERROR, nonNull, PARSE_ERROR, resolveLocale, UNSUPPORTED_ERROR, } from "./locale.js";
+// NumberFormatter's negativeNumberFormat: where the negative symbol goes, "n" the number.
+const NEGATIVE_NUMBER = ["(n)", "-n", "- n", "n-", "n -"];
+// The bidi marks ICU sets around signs and symbols, which Windows has not.
+const BIDI = /[\u061c\u200e\u200f]/g;
+/** The pattern of Intl's parts: the number as "n", its sign as "-", the currency as "$". */
+export function partsPattern(parts) {
+    let pattern = "";
+    for (const { type, value } of parts) {
+        let token;
+        switch (type) {
+            case "literal":
+                token = value
+                    .replace(BIDI, "")
+                    .replace(/\s+/g, " ")
+                    .replace(/[^() ]/g, "");
+                break;
+            case "minusSign":
+                token = "-";
+                break;
+            case "currency":
+                token = "$";
+                break;
+            default:
+                token = pattern.endsWith("n") ? "" : "n";
+        }
+        pattern += token;
+    }
+    return pattern;
+}
+// Group sizes, the last repeated with a "*": five fields at most.
+const GROUPING = /^(?=.{1,9}$)([1-9](;[1-9])*(;\*)?|\*)$/;
+// Separators longer than three characters Windows refuses.
+const SEPARATOR_MAX = 3;
+// adl crashes formatting a thousand fractional digits; none are padded past that.
+const FRACTION_MAX = 1000;
+const numberData = new Map();
+function localeNumbers(locale) {
+    let data = numberData.get(locale);
+    if (data) {
+        return data;
+    }
+    const nf = new Intl.NumberFormat(locale);
+    const parts = nf.formatToParts(-1234567890.5);
+    const value = (type, otherwise) => parts.find((p) => p.type === type)?.value.replace(BIDI, "") ?? otherwise;
+    const groups = parts.filter((p) => p.type === "integer").map((p) => p.value.length);
+    const primary = groups[groups.length - 1];
+    const secondary = groups[groups.length - 2] ?? primary;
+    data = {
+        decimal: value("decimal", "."),
+        group: value("group", ","),
+        // Flash's negative symbol is one character; ICU gives some locales U+2212 where Windows has "-".
+        minus: value("minusSign", "-").replace("\u2212", "-"),
+        digits: nf.format(0).codePointAt(0) ?? 48,
+        grouping: secondary === primary ? `${primary};*` : `${primary};${secondary};*`,
+        negative: Math.max(0, NEGATIVE_NUMBER.indexOf(partsPattern(parts))),
+    };
+    numberData.set(locale, data);
+    return data;
+}
+/** A locale's number settings, as a NumberFormatter or CurrencyFormatter holds them, and its status. */
+export class NumberSettings {
+    status;
+    locale;
+    fractionalDigits = 2;
+    useGrouping = true;
+    groupingPattern;
+    digitsType;
+    decimalSeparator;
+    groupingSeparator;
+    negativeSymbol;
+    negativeFormat;
+    leadingZero = true;
+    trailingZeros = true;
+    constructor(locale) {
+        this.locale = locale;
+        this.status = locale.status;
+        const data = localeNumbers(locale.actual);
+        this.decimalSeparator = data.decimal;
+        this.groupingSeparator = data.group;
+        this.negativeSymbol = data.minus;
+        this.digitsType = data.digits;
+        this.groupingPattern = data.grouping;
+        this.negativeFormat = data.negative;
+    }
+    /** A setting's new value kept if valid; Flash's status says which. */
+    set(key, value, valid = true) {
+        if (valid) {
+            this[key] = value;
+        }
+        this.status = valid ? NO_ERROR : ILLEGAL_ARGUMENT_ERROR;
+    }
+    setFractionalDigits(n) {
+        this.set("fractionalDigits", n, n >= 0);
+    }
+    setGroupingPattern(pattern) {
+        this.set("groupingPattern", pattern, GROUPING.test(pattern));
+    }
+    // Flash's strings are C strings: a NUL ends a separator.
+    setDecimalSeparator(given) {
+        const separator = given.split("\0")[0];
+        this.set("decimalSeparator", separator, separator !== "" && separator.length <= SEPARATOR_MAX);
+    }
+    setGroupingSeparator(given) {
+        const separator = given.split("\0")[0];
+        this.set("groupingSeparator", separator, separator.length <= SEPARATOR_MAX);
+    }
+    /**
+     * Digits from a zero: past int's range an illegal argument; past Unicode's
+     * last nine, a surrogate or a noncharacter invalid.
+     */
+    setDigitsType(zero) {
+        const invalid = zero + 9 > 0x10ffff || (zero >= 0xd800 && zero <= 0xdfff) || (zero & 0xfffe) === 0xfffe;
+        if (zero <= 0x7fffffff && invalid) {
+            this.status = INVALID_ATTR_VALUE;
+            return;
+        }
+        this.set("digitsType", zero, zero <= 0x7fffffff);
+    }
+    /** A format among `count`: above them invalid, past int's range an illegal argument. */
+    setFormat(n, count) {
+        this.status =
+            n > 0x7fffffff ? ILLEGAL_ARGUMENT_ERROR : n >= count ? INVALID_ATTR_VALUE : NO_ERROR;
+        return this.status === NO_ERROR;
+    }
+    setNegativeFormat(n) {
+        if (this.setFormat(n, NEGATIVE_NUMBER.length)) {
+            this.negativeFormat = n;
+        }
+    }
+    /**
+     * The digits of a number's magnitude, grouped. Flash prints the number
+     * with nine decimals and rounds that half up to the digits asked for.
+     */
+    digits(magnitude) {
+        const fractionalDigits = Math.min(this.fractionalDigits, FRACTION_MAX);
+        const fixed = magnitude < 1e21 ? magnitude.toFixed(9) : `${BigInt(magnitude)}.000000000`;
+        let [whole, fraction] = fixed.split(".");
+        if (fractionalDigits < 9) {
+            const up = fraction.charCodeAt(fractionalDigits) >= 53;
+            fraction = fraction.slice(0, fractionalDigits);
+            if (up) {
+                const sum = (BigInt(whole + fraction) + 1n)
+                    .toString()
+                    .padStart(whole.length + fraction.length, "0");
+                whole = sum.slice(0, sum.length - fraction.length);
+                fraction = sum.slice(whole.length);
+            }
+        }
+        else {
+            fraction = fraction.padEnd(fractionalDigits, "0");
+        }
+        if (!this.trailingZeros) {
+            fraction = fraction.replace(/0+$/, "");
+        }
+        if (!this.leadingZero && whole === "0") {
+            whole = "";
+        }
+        const grouped = this.useGrouping ? this.group(whole) : whole;
+        const text = fraction === "" ? grouped : grouped + this.decimalSeparator + fraction;
+        return this.digitsType === 48 ? text : this.localDigits(text);
+    }
+    group(whole) {
+        const pattern = this.groupingPattern.split(";");
+        const repeat = pattern[pattern.length - 1] === "*";
+        const sizes = (repeat ? pattern.slice(0, -1) : pattern).map(Number);
+        const chunks = [];
+        let end = whole.length;
+        for (let i = 0; end > 0; i++) {
+            const size = i < sizes.length ? sizes[i] : repeat && sizes.length > 0 ? sizes[sizes.length - 1] : end;
+            chunks.unshift(whole.slice(Math.max(0, end - size), end));
+            end -= size;
+        }
+        return chunks.join(this.groupingSeparator);
+    }
+    localDigits(text) {
+        return text.replace(/[0-9]/g, (d) => String.fromCodePoint(this.digitsType + Number(d)));
+    }
+    /** A number formatted, `pattern` placing its sign and digits: Flash's infinities and NaN keep none. */
+    format(value, pattern, symbol = "") {
+        this.status = NO_ERROR;
+        if (Number.isNaN(value)) {
+            return "NaN";
+        }
+        if (!Number.isFinite(value)) {
+            return value > 0 ? "\u221e" : `${this.negativeSymbol}\u221e`;
+        }
+        const negative = value < 0 || Object.is(value, -0);
+        let out = "";
+        for (const c of pattern(negative)) {
+            switch (c) {
+                case "n":
+                    out += this.digits(Math.abs(value));
+                    break;
+                case "-":
+                    out += this.negativeSymbol;
+                    break;
+                case "$":
+                    out += symbol;
+                    break;
+                default:
+                    out += c;
+            }
+        }
+        // Flash's strings are C strings: digits from zero end it at a NUL.
+        const nul = out.indexOf("\0");
+        return nul < 0 ? out : out.slice(0, nul);
+    }
+    /**
+     * The first number in `text` as Flash finds it: digits of any script,
+     * group separators between digits, one decimal separator; its sign by
+     * the negative format around it. Null where there is none.
+     */
+    findNumber(text) {
+        let start = -1;
+        for (let i = 0; i < text.length; i++) {
+            if (digit(text, i) >= 0 ||
+                (text.startsWith(this.decimalSeparator, i) &&
+                    digit(text, i + this.decimalSeparator.length) >= 0)) {
+                start = i;
+                break;
+            }
+        }
+        if (start < 0) {
+            return null;
+        }
+        let number = "";
+        let i = start;
+        for (;;) {
+            const d = digit(text, i);
+            if (d >= 0) {
+                number += d;
+                i += 1;
+            }
+            else if (this.groupingSeparator !== "" &&
+                !number.includes(".") &&
+                number !== "" &&
+                text.startsWith(this.groupingSeparator, i) &&
+                digit(text, i + this.groupingSeparator.length) >= 0) {
+                i += this.groupingSeparator.length;
+            }
+            else if (!number.includes(".") && text.startsWith(this.decimalSeparator, i)) {
+                number += ".";
+                i += this.decimalSeparator.length;
+            }
+            else {
+                break;
+            }
+        }
+        let value = Number(number);
+        let end = i;
+        // A sign or parenthesis stands at most a space from the number; U+2212 is a minus too.
+        const signs = this.negativeSymbol === "-" ? ["-", "\u2212"] : [this.negativeSymbol];
+        const before = skipSpace(text, start, -1);
+        const after = skipSpace(text, end, 1);
+        switch (this.negativeFormat) {
+            case 0:
+                if (text[before - 1] === "(" && text[after] === ")") {
+                    value = -value;
+                    start = before - 1;
+                    end = after + 1;
+                }
+                break;
+            case 1:
+            case 2: {
+                const sign = signs.find((sign) => text.slice(0, before).endsWith(sign));
+                if (sign) {
+                    value = -value;
+                    start = before - sign.length;
+                }
+                break;
+            }
+            default: {
+                const sign = signs.find((sign) => text.startsWith(sign, after));
+                if (sign) {
+                    value = -value;
+                    end = after + sign.length;
+                }
+            }
+        }
+        return { value, start, end };
+    }
+    parse(text) {
+        if (text === "") {
+            this.status = ILLEGAL_ARGUMENT_ERROR;
+            return { value: Number.NaN, start: 0x7fffffff, end: 0x7fffffff };
+        }
+        const found = this.findNumber(text);
+        this.status = found ? NO_ERROR : PARSE_ERROR;
+        return found ?? { value: Number.NaN, start: 0x7fffffff, end: 0x7fffffff };
+    }
+    /** A number filling `text` but for spaces; NaN otherwise. */
+    parseNumber(text) {
+        const { value, start, end } = this.parse(text);
+        if (this.status !== NO_ERROR) {
+            return value;
+        }
+        if (skipSpaces(text, start, -1) > 0 || skipSpaces(text, end, 1) < text.length) {
+            this.status = PARSE_ERROR;
+            return Number.NaN;
+        }
+        return value;
+    }
+}
+/** The value of the decimal digit at `i`, of any script, or -1. */
+export function digit(text, i) {
+    const c = text.codePointAt(i);
+    if (c === undefined || !/\p{Nd}/u.test(String.fromCodePoint(c))) {
+        return -1;
+    }
+    // Unicode's decimal digits come in runs of ten from zero.
+    let zero = c;
+    while (zero > 0 && /\p{Nd}/u.test(String.fromCodePoint(zero - 1))) {
+        zero--;
+    }
+    return (c - zero) % 10;
+}
+const isSpace = (c) => c !== undefined && /\p{Zs}/u.test(c);
+// The spaces that may stand between a sign and its number: plain, no-break, narrow and ideographic.
+const SIGN_SPACES = " \u00a0\u202f\u3000";
+/** The index past one space at `i` in direction `step`, if there is one. */
+function skipSpace(text, i, step) {
+    const c = step > 0 ? text[i] : text[i - 1];
+    return c !== undefined && SIGN_SPACES.includes(c) ? i + step : i;
+}
+/** The index past the spaces from `i` on in direction `step`: Flash's spaces are Unicode's space separators. */
+function skipSpaces(text, i, step) {
+    const at = step > 0 ? (j) => text[j] : (j) => text[j - 1];
+    while (isSpace(at(i))) {
+        i += step;
+    }
+    return i;
+}
+export function numberFormatterNatives(s) {
+    const natives = {};
+    const settings = (o) => o.$settings;
+    const format = (o, value) => {
+        const f = settings(o);
+        return f.format(value, (negative) => (negative ? NEGATIVE_NUMBER[f.negativeFormat] : "n"));
+    };
+    class NumberFormatterNatives {
+        static getAvailableLocaleIDNames() {
+            return availableLocales(s);
+        }
+        "flash.globalization:NumberFormatter::ctor"(name) {
+            this.$settings = new NumberSettings(resolveLocale(s, nonNull(s, name, "requestedLocaleIDName")));
+        }
+        get lastOperationStatus() {
+            return settings(this).status;
+        }
+        get requestedLocaleIDName() {
+            return settings(this).locale.requested;
+        }
+        get actualLocaleIDName() {
+            return settings(this).locale.actual;
+        }
+        get fractionalDigits() {
+            return settings(this).fractionalDigits;
+        }
+        set fractionalDigits(n) {
+            settings(this).setFractionalDigits(n);
+        }
+        get useGrouping() {
+            return settings(this).useGrouping;
+        }
+        set useGrouping(v) {
+            settings(this).set("useGrouping", v);
+        }
+        get groupingPattern() {
+            return settings(this).groupingPattern;
+        }
+        set groupingPattern(v) {
+            settings(this).setGroupingPattern(nonNull(s, v, "value"));
+        }
+        get digitsType() {
+            return settings(this).digitsType;
+        }
+        set digitsType(v) {
+            settings(this).setDigitsType(v);
+        }
+        get decimalSeparator() {
+            return settings(this).decimalSeparator;
+        }
+        set decimalSeparator(v) {
+            settings(this).setDecimalSeparator(nonNull(s, v, "value"));
+        }
+        get groupingSeparator() {
+            return settings(this).groupingSeparator;
+        }
+        set groupingSeparator(v) {
+            settings(this).setGroupingSeparator(nonNull(s, v, "value"));
+        }
+        get negativeSymbol() {
+            return settings(this).negativeSymbol;
+        }
+        // Windows keeps the locale's.
+        set negativeSymbol(v) {
+            nonNull(s, v, "value");
+            settings(this).status = UNSUPPORTED_ERROR;
+        }
+        get negativeNumberFormat() {
+            return settings(this).negativeFormat;
+        }
+        set negativeNumberFormat(n) {
+            settings(this).setNegativeFormat(n);
+        }
+        get leadingZero() {
+            return settings(this).leadingZero;
+        }
+        set leadingZero(v) {
+            settings(this).set("leadingZero", v);
+        }
+        get trailingZeros() {
+            return settings(this).trailingZeros;
+        }
+        set trailingZeros(v) {
+            settings(this).set("trailingZeros", v);
+        }
+        formatInt(value) {
+            return format(this, value);
+        }
+        formatUint(value) {
+            return format(this, value);
+        }
+        formatNumber(value) {
+            return format(this, value);
+        }
+        parse(text) {
+            const { value, start, end } = settings(this).parse(nonNull(s, text, "parseString"));
+            return s.rt.construct(s.rt.classNamed("flash.globalization::NumberParseResult"), value, start, end);
+        }
+        parseNumber(text) {
+            return settings(this).parseNumber(nonNull(s, text, "parseString"));
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::NumberFormatter", NumberFormatterNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/globalization/NumberParseResult.js

@@ -0,0 +1,22 @@
+import { avm2 } from "../../../../runtime/index.js";
+export function numberParseResultNatives() {
+    const natives = {};
+    class NumberParseResultNatives {
+        "flash.globalization:NumberParseResult::ctor"(value, startIndex, endIndex) {
+            this.$numberValue = value;
+            this.$startIndex = startIndex;
+            this.$endIndex = endIndex;
+        }
+        get value() {
+            return this.$numberValue;
+        }
+        get startIndex() {
+            return this.$startIndex;
+        }
+        get endIndex() {
+            return this.$endIndex;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::NumberParseResult", NumberParseResultNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/globalization/StringTools.js

@@ -0,0 +1,59 @@
+// flash.globalization.StringTools: case mapping character by character, as
+// Windows maps case: no context, as a final sigma's, and no locale's rules
+// but Turkish, Azerbaijani and Lithuanian ones, so Greek keeps its accents.
+// A character whose full mapping expands takes its simple one where its
+// decomposition gives one (ᾳ to ᾼ) and stays as it is otherwise (fi, ʼn),
+// but for ß, which Flash makes SS, and İ, which it lowers to i.
+import { avm2 } from "../../../../runtime/index.js";
+import { availableLocales, NO_ERROR, nonNull, resolveLocale } from "./locale.js";
+const CASED_LOCALES = /^(tr|az|lt)\b/;
+function mapCase(text, locale, lower) {
+    const rules = CASED_LOCALES.test(locale) ? locale : "und";
+    const map = (c) => (lower ? c.toLocaleLowerCase(rules) : c.toLocaleUpperCase(rules));
+    let out = "";
+    for (const c of text) {
+        const mapped = [...map(c)];
+        if (mapped.length === 1 || c === "\u00df") {
+            out += mapped.join("");
+            continue;
+        }
+        // The base letter mapped, its marks kept: the simple mapping, if it is one character
+        // (Lithuanian's Ì lowers to ì); else a lower case keeps its first character, the dotted
+        // I's i, and an upper case the character as it is.
+        const [base, ...marks] = [...c.normalize("NFD")];
+        const simple = [...(map(base) + marks.join("")).normalize("NFC")];
+        out += simple.length === 1 ? simple[0] : lower ? mapped[0] : c;
+    }
+    return out;
+}
+export function stringToolsNatives(s) {
+    const natives = {};
+    class StringToolsNatives {
+        static getAvailableLocaleIDNames() {
+            return availableLocales(s);
+        }
+        "flash.globalization:StringTools::ctor"(name) {
+            this.$locale = resolveLocale(s, nonNull(s, name, "requestedLocaleIDName"));
+            this.$status = this.$locale.status;
+        }
+        get lastOperationStatus() {
+            return this.$status;
+        }
+        get requestedLocaleIDName() {
+            return this.$locale.requested;
+        }
+        get actualLocaleIDName() {
+            return this.$locale.actual;
+        }
+        toLowerCase(text) {
+            this.$status = NO_ERROR;
+            return mapCase(nonNull(s, text, "s"), this.$locale.actual, true);
+        }
+        toUpperCase(text) {
+            this.$status = NO_ERROR;
+            return mapCase(nonNull(s, text, "s"), this.$locale.actual, false);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::StringTools", StringToolsNatives);
+    return natives;
+}