@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/globalization/Collator.ts

@@ -0,0 +1,205 @@
+// flash.globalization.Collator onto Intl.Collator. Intl has no options for
+// character width or kana, so those fold the strings before comparing:
+// full- and half-width forms to their plain ones, hiragana to katakana.
+// Where ICU's order and Windows' differ in their data (kana, widths), ICU's stands.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import {
+  availableLocales,
+  type Locale,
+  NO_ERROR,
+  nonNull,
+  resolveLocale,
+  UNSUPPORTED_ERROR,
+} from "./locale.js";
+
+type Value = avm2.Value;
+
+type Option =
+  | "ignoreCase"
+  | "ignoreDiacritics"
+  | "ignoreKanaType"
+  | "ignoreSymbols"
+  | "ignoreCharacterWidth"
+  | "numericComparison";
+
+class CollatorSettings {
+  status: string;
+  readonly locale: Locale;
+  ignoreCase: boolean;
+  ignoreDiacritics: boolean;
+  ignoreKanaType: boolean;
+  ignoreSymbols: boolean;
+  ignoreCharacterWidth: boolean;
+  numericComparison = false;
+  private collator: Intl.Collator | null = null;
+
+  constructor(locale: Locale, matching: boolean) {
+    this.locale = locale;
+    this.status = locale.status;
+    this.ignoreCase = matching;
+    this.ignoreDiacritics = matching;
+    this.ignoreKanaType = matching;
+    this.ignoreSymbols = matching;
+    this.ignoreCharacterWidth = matching;
+  }
+
+  set(option: Option, value: boolean): void {
+    this[option] = value;
+    this.collator = null;
+    // Flash in adl reports numeric comparison unsupported, and compares as it would without it.
+    this.status = option === "numericComparison" ? UNSUPPORTED_ERROR : NO_ERROR;
+  }
+
+  compare(a: string, b: string): number {
+    this.collator ??= new Intl.Collator(this.locale.actual, {
+      sensitivity: this.ignoreCase
+        ? this.ignoreDiacritics
+          ? "base"
+          : "accent"
+        : this.ignoreDiacritics
+          ? "case"
+          : "variant",
+      ignorePunctuation: this.ignoreSymbols,
+    });
+    this.status = NO_ERROR;
+    // Windows tells a string of what it ignores alone from the empty one.
+    if ((a === "") !== (b === "")) {
+      return a === "" ? -1 : 1;
+    }
+
+    a = this.fold(a);
+    b = this.fold(b);
+    // Windows' word sort sets hyphens and apostrophes aside, so that "co-op" stays beside
+    // "coop": compared without them, then by how many each has, after the same word without.
+    const words = (text: string) => text.replace(/['-]/g, "");
+    const count = (text: string) => text.length - words(text).length;
+    if (this.ignoreSymbols) {
+      return this.collator.compare(a, b);
+    }
+
+    return (
+      this.collator.compare(words(a), words(b)) ||
+      Math.sign(count(a) - count(b)) ||
+      this.collator.compare(a, b)
+    );
+  }
+
+  private fold(text: string): string {
+    // Windows takes ß for ss at every strength, where ICU tells them apart.
+    text = text.replaceAll("\u00df", "ss").replaceAll("\u1e9e", "SS");
+    if (this.ignoreCharacterWidth) {
+      text = text.replace(/[\uff01-\uffee]/g, (c) => c.normalize("NFKC"));
+    }
+
+    if (this.ignoreKanaType) {
+      text = text.replace(/[\u3041-\u3096\u309d\u309e]/g, (c) =>
+        String.fromCharCode(c.charCodeAt(0) + 0x60),
+      );
+    }
+
+    // ICU's ignorePunctuation leaves symbols ("$1" against "1"), which Windows ignores too.
+    if (this.ignoreSymbols) {
+      text = text.replace(/\p{S}/gu, "");
+    }
+
+    return text;
+  }
+}
+
+export function collatorNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const settings = (o: CollatorNatives) => o.$settings;
+  const strings = (a: string | null, b: string | null): [string, string] => [
+    nonNull(s, a, "string1"),
+    nonNull(s, b, "string2"),
+  ];
+
+  class CollatorNatives {
+    declare $settings: CollatorSettings;
+
+    static getAvailableLocaleIDNames(): Value {
+      return availableLocales(s);
+    }
+
+    "flash.globalization:Collator::ctor"(name: string | null, mode: string | null): void {
+      const locale = resolveLocale(s, nonNull(s, name, "requestedLocaleIDName"));
+      if (nonNull(s, mode, "initialMode") !== "sorting" && mode !== "matching") {
+        throw s.rt.error("ArgumentError", 1508, "initialMode");
+      }
+
+      this.$settings = new CollatorSettings(locale, mode === "matching");
+    }
+
+    get lastOperationStatus(): string {
+      return settings(this).status;
+    }
+
+    get requestedLocaleIDName(): string {
+      return settings(this).locale.requested;
+    }
+
+    get actualLocaleIDName(): string {
+      return settings(this).locale.actual;
+    }
+
+    get ignoreCase(): boolean {
+      return settings(this).ignoreCase;
+    }
+
+    set ignoreCase(v: boolean) {
+      settings(this).set("ignoreCase", v);
+    }
+
+    get ignoreDiacritics(): boolean {
+      return settings(this).ignoreDiacritics;
+    }
+
+    set ignoreDiacritics(v: boolean) {
+      settings(this).set("ignoreDiacritics", v);
+    }
+
+    get ignoreKanaType(): boolean {
+      return settings(this).ignoreKanaType;
+    }
+
+    set ignoreKanaType(v: boolean) {
+      settings(this).set("ignoreKanaType", v);
+    }
+
+    get ignoreSymbols(): boolean {
+      return settings(this).ignoreSymbols;
+    }
+
+    set ignoreSymbols(v: boolean) {
+      settings(this).set("ignoreSymbols", v);
+    }
+
+    get ignoreCharacterWidth(): boolean {
+      return settings(this).ignoreCharacterWidth;
+    }
+
+    set ignoreCharacterWidth(v: boolean) {
+      settings(this).set("ignoreCharacterWidth", v);
+    }
+
+    get numericComparison(): boolean {
+      return settings(this).numericComparison;
+    }
+
+    set numericComparison(v: boolean) {
+      settings(this).set("numericComparison", v);
+    }
+
+    compare(a: string | null, b: string | null): number {
+      return settings(this).compare(...strings(a, b));
+    }
+
+    equals(a: string | null, b: string | null): boolean {
+      return settings(this).compare(...strings(a, b)) === 0;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.globalization::Collator", CollatorNatives);
+  return natives;
+}

package/src/playerglobal/flash/globalization/CurrencyFormatter.ts

@@ -0,0 +1,365 @@
+// flash.globalization.CurrencyFormatter: NumberFormatter's settings and
+// digits, placed with the currency by Windows' currency formats, which
+// are Flash's. A locale's own formats are found in Intl's: its accounting
+// format, which ICU gives the parentheses Windows uses, is its negative one.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import {
+  availableLocales,
+  currencyOf,
+  ILLEGAL_ARGUMENT_ERROR,
+  type Locale,
+  NO_ERROR,
+  nonNull,
+  PARSE_ERROR,
+  resolveLocale,
+  UNSUPPORTED_ERROR,
+} from "./locale.js";
+import { digit, NumberSettings, partsPattern } from "./NumberFormatter.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+// Windows' positive and negative currency formats: "$" the currency, "-" the negative symbol, "n" the number.
+const POSITIVE = ["$n", "n$", "$ n", "n $"];
+const NEGATIVE = [
+  "($n)",
+  "-$n",
+  "$-n",
+  "$n-",
+  "(n$)",
+  "-n$",
+  "n-$",
+  "n$-",
+  "-n $",
+  "-$ n",
+  "n $-",
+  "$ n-",
+  "$ -n",
+  "n- $",
+  "($ n)",
+  "(n $)",
+];
+
+/** A locale's own currency settings, read off Intl once per locale. */
+interface CurrencyData {
+  code: string;
+  symbol: string;
+  digits: number;
+  positive: number;
+  negative: number;
+}
+
+const currencyData = new Map<string, CurrencyData>();
+
+function localeCurrency(locale: string): CurrencyData {
+  let data = currencyData.get(locale);
+  if (data) {
+    return data;
+  }
+
+  const code = currencyOf(locale);
+  // A narrow symbol has ICU place it as the locale's pattern says, with no spacing of its own;
+  // a region with no currency of its own (XDR) is placed as the dollar would be.
+  const options = {
+    style: "currency",
+    currency: code === "XDR" ? "USD" : code,
+    currencyDisplay: "narrowSymbol",
+  } as const;
+  const parts = new Intl.NumberFormat(locale, options).formatToParts(1234.5);
+  const accounting = new Intl.NumberFormat(locale, { ...options, currencySign: "accounting" });
+  const own = new Intl.NumberFormat(locale, { style: "currency", currency: code });
+  data = {
+    code,
+    // The narrow symbol is Windows' ("$" in Hong Kong, not "HK$"); Windows gives a region of
+    // several countries' currency none.
+    symbol: code === "XDR" ? "" : (parts.find((p) => p.type === "currency")?.value ?? code),
+    digits: own.resolvedOptions().maximumFractionDigits ?? 2,
+    positive: Math.max(0, POSITIVE.indexOf(partsPattern(parts))),
+    negative: Math.max(0, NEGATIVE.indexOf(partsPattern(accounting.formatToParts(-1234.5)))),
+  };
+  currencyData.set(locale, data);
+  return data;
+}
+
+class CurrencySettings extends NumberSettings {
+  currencyISOCode: string;
+  currencySymbol: string;
+  positiveFormat: number;
+  negativeCurrencyFormat: number;
+
+  constructor(locale: Locale) {
+    super(locale);
+    const data = localeCurrency(locale.actual);
+    this.currencyISOCode = data.code;
+    this.currencySymbol = data.symbol;
+    this.fractionalDigits = data.digits;
+    this.positiveFormat = data.positive;
+    this.negativeCurrencyFormat = data.negative;
+  }
+
+  /**
+   * A currency amount filling `text` but for spaces, as the negative format
+   * or the positive one places it: the currency is what stands where the
+   * pattern has it, spaces allowed between it and the number.
+   */
+  parseCurrency(text: string): { value: number; symbol: string } {
+    if (text === "") {
+      this.status = ILLEGAL_ARGUMENT_ERROR;
+      return { value: Number.NaN, symbol: "" };
+    }
+
+    for (const negative of [true, false]) {
+      const pattern = negative
+        ? NEGATIVE[this.negativeCurrencyFormat]
+        : POSITIVE[this.positiveFormat];
+      const groups = this.patternRegExp(pattern).exec(text)?.groups;
+      if (groups) {
+        const digits = groups.number;
+        let number = "";
+        for (let i = 0; i < digits.length; i++) {
+          const d = digit(digits, i);
+          number += d >= 0 ? d : digits.startsWith(this.decimalSeparator, i) ? "." : "";
+        }
+
+        this.status = NO_ERROR;
+        return { value: negative ? -Number(number) : Number(number), symbol: groups.symbol ?? "" };
+      }
+    }
+
+    this.status = PARSE_ERROR;
+    return { value: Number.NaN, symbol: "" };
+  }
+
+  private patternRegExp(pattern: string): RegExp {
+    const literal = (text: string) => text.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
+    const sign = literal(this.negativeSymbol);
+    // A currency holds no sign or parentheses; it begins with no space before the number and
+    // ends with none after it, where one space parts them and any more are the currency's.
+    // Before the number it is as short as leaves one ("$.5" is "$" and .5), but a number does
+    // not begin after a decimal separator ("$.5.5").
+    const not = `()\\u2212${this.negativeSymbol.replace(/[\\\]^-]/g, "\\$&")}`;
+    const symbolBefore = `(?<symbol>[^\\p{Nd}\\p{Zs}${not}](?:[^\\p{Nd}${not}]*?[^\\p{Nd}${not}])??)?`;
+    const symbolAfter = `(?<symbol>[^${not}](?:[^${not}]*[^\\p{Zs}${not}])?)?`;
+    const group = this.groupingSeparator === "" ? "" : `(?:${literal(this.groupingSeparator)})?`;
+    const decimal = literal(this.decimalSeparator);
+    const number = `(?<!${decimal})(?<number>\\p{Nd}(?:${group}\\p{Nd})*(?:${decimal}\\p{Nd}*)?|${decimal}\\p{Nd}+)`;
+    const before = pattern.indexOf("$") < pattern.indexOf("n");
+    let source = "";
+    let previous = "";
+    let spaced = false;
+    for (const c of pattern) {
+      if (c === " ") {
+        spaced = true;
+        continue;
+      }
+
+      if (spaced || (c === "$" && previous === "n") || (c === "n" && previous === "$")) {
+        source += "\\p{Zs}?";
+      }
+
+      switch (c) {
+        case "(":
+        case ")":
+          source += `\\${c}`;
+          break;
+        case "-":
+          source += sign;
+          break;
+        case "$":
+          source += before ? symbolBefore : symbolAfter;
+          break;
+        case "n":
+          source += number;
+          break;
+      }
+
+      previous = c;
+      spaced = false;
+    }
+
+    return new RegExp(`^\\p{Zs}*${source}\\p{Zs}*$`, "u");
+  }
+}
+
+export function currencyFormatterNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const settings = (o: CurrencyFormatterNatives) => o.$settings;
+
+  class CurrencyFormatterNatives {
+    declare $settings: CurrencySettings;
+
+    static getAvailableLocaleIDNames(): Value {
+      return availableLocales(s);
+    }
+
+    "flash.globalization:CurrencyFormatter::ctor"(name: string | null): void {
+      this.$settings = new CurrencySettings(
+        resolveLocale(s, nonNull(s, name, "requestedLocaleIDName")),
+      );
+    }
+
+    get lastOperationStatus(): string {
+      return settings(this).status;
+    }
+
+    get requestedLocaleIDName(): string {
+      return settings(this).locale.requested;
+    }
+
+    get actualLocaleIDName(): string {
+      return settings(this).locale.actual;
+    }
+
+    get currencyISOCode(): string {
+      return settings(this).currencyISOCode;
+    }
+
+    get currencySymbol(): string {
+      return settings(this).currencySymbol;
+    }
+
+    setCurrency(code: string | null, symbol: string | null): void {
+      const f = settings(this);
+      nonNull(s, code, "currencyISOCode");
+      nonNull(s, symbol, "currencySymbol");
+      const valid = /^[A-Z]{3}$/.test(code as string);
+      if (valid) {
+        f.currencyISOCode = code as string;
+        f.currencySymbol = symbol as string;
+      }
+
+      f.status = valid ? NO_ERROR : ILLEGAL_ARGUMENT_ERROR;
+    }
+
+    "flash.globalization:CurrencyFormatter::formatImplementation"(
+      value: number,
+      withSymbol: boolean,
+    ): string {
+      const f = settings(this);
+      return f.format(
+        value,
+        (negative) => (negative ? NEGATIVE[f.negativeCurrencyFormat] : POSITIVE[f.positiveFormat]),
+        withSymbol ? f.currencySymbol : f.currencyISOCode,
+      );
+    }
+
+    formattingWithCurrencySymbolIsSafe(code: string | null): boolean {
+      const f = settings(this);
+      f.status = NO_ERROR;
+      return nonNull(s, code, "requestedISOCode") === f.currencyISOCode;
+    }
+
+    parse(text: string | null): AsObject {
+      const { value, symbol } = settings(this).parseCurrency(nonNull(s, text, "value"));
+      return s.rt.construct(
+        s.rt.classNamed("flash.globalization::CurrencyParseResult"),
+        value,
+        symbol,
+      ) as AsObject;
+    }
+
+    get fractionalDigits(): number {
+      return settings(this).fractionalDigits;
+    }
+
+    set fractionalDigits(n: number) {
+      settings(this).setFractionalDigits(n);
+    }
+
+    get useGrouping(): boolean {
+      return settings(this).useGrouping;
+    }
+
+    set useGrouping(v: boolean) {
+      settings(this).set("useGrouping", v);
+    }
+
+    get groupingPattern(): string {
+      return settings(this).groupingPattern;
+    }
+
+    set groupingPattern(v: string | null) {
+      settings(this).setGroupingPattern(nonNull(s, v, "value"));
+    }
+
+    get digitsType(): number {
+      return settings(this).digitsType;
+    }
+
+    set digitsType(v: number) {
+      settings(this).setDigitsType(v);
+    }
+
+    get decimalSeparator(): string {
+      return settings(this).decimalSeparator;
+    }
+
+    set decimalSeparator(v: string | null) {
+      settings(this).setDecimalSeparator(nonNull(s, v, "value"));
+    }
+
+    get groupingSeparator(): string {
+      return settings(this).groupingSeparator;
+    }
+
+    set groupingSeparator(v: string | null) {
+      settings(this).setGroupingSeparator(nonNull(s, v, "value"));
+    }
+
+    get negativeSymbol(): string {
+      return settings(this).negativeSymbol;
+    }
+
+    // Windows keeps the locale's.
+    set negativeSymbol(v: string | null) {
+      nonNull(s, v, "value");
+      settings(this).status = UNSUPPORTED_ERROR;
+    }
+
+    get negativeCurrencyFormat(): number {
+      return settings(this).negativeCurrencyFormat;
+    }
+
+    set negativeCurrencyFormat(n: number) {
+      const f = settings(this);
+      if (f.setFormat(n, NEGATIVE.length)) {
+        f.negativeCurrencyFormat = n;
+      }
+    }
+
+    get positiveCurrencyFormat(): number {
+      return settings(this).positiveFormat;
+    }
+
+    set positiveCurrencyFormat(n: number) {
+      const f = settings(this);
+      if (f.setFormat(n, POSITIVE.length)) {
+        f.positiveFormat = n;
+      }
+    }
+
+    get leadingZero(): boolean {
+      return settings(this).leadingZero;
+    }
+
+    set leadingZero(v: boolean) {
+      settings(this).set("leadingZero", v);
+    }
+
+    get trailingZeros(): boolean {
+      return settings(this).trailingZeros;
+    }
+
+    set trailingZeros(v: boolean) {
+      settings(this).set("trailingZeros", v);
+    }
+  }
+
+  avm2.registerNativeClass(
+    natives,
+    "flash.globalization::CurrencyFormatter",
+    CurrencyFormatterNatives,
+  );
+  return natives;
+}

package/src/playerglobal/flash/globalization/CurrencyParseResult.ts

@@ -0,0 +1,35 @@
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+export function currencyParseResultNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class CurrencyParseResultNatives {
+    declare $currencyValue: number;
+    declare $currencyString: string | null;
+
+    "flash.globalization:CurrencyParseResult::ctor"(value: number, symbol: string | null): void {
+      if (symbol === null) {
+        throw s.rt.error("TypeError", 2007, "symbol");
+      }
+
+      this.$currencyValue = value;
+      this.$currencyString = symbol;
+    }
+
+    get value(): number {
+      return this.$currencyValue;
+    }
+
+    get currencyString(): string | null {
+      return this.$currencyString;
+    }
+  }
+
+  avm2.registerNativeClass(
+    natives,
+    "flash.globalization::CurrencyParseResult",
+    CurrencyParseResultNatives,
+  );
+  return natives;
+}