@watermarkinsights/ripple 5.3.0 → 5.3.1-1

package/dist/collection/components/wm-uploader/wm-uploader.spec.js

@@ -0,0 +1,234 @@
+jest.mock("../../global/services/http-service");
+import { newSpecPage } from "@stencil/core/testing";
+import { Uploader } from "./wm-uploader";
+import { File } from "../wm-file/wm-file";
+// mock ResizeObserver
+global.ResizeObserver = jest.fn().mockImplementation(() => ({
+    observe: jest.fn(),
+    unobserve: jest.fn(),
+    disconnect: jest.fn(),
+}));
+// mock MutationObserver
+global.MutationObserver = jest.fn().mockImplementation(() => ({
+    observe: jest.fn(),
+    unobserve: jest.fn(),
+    disconnect: jest.fn(),
+}));
+describe("wm-uploader", () => {
+    let html, page;
+    beforeEach(async () => {
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    max-size="200 MB"
+    max-files="5"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+    });
+    afterEach(() => {
+        html = undefined;
+        page = undefined;
+    });
+    it("has necessary aria properties", async () => {
+        let inputEl = page.root.shadowRoot.querySelector("input");
+        expect(inputEl).toEqualAttribute("aria-describedby", "file-count max-size accepted-types");
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    label="example label"
+    required-field="true"
+    ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        inputEl = page.root.shadowRoot.querySelector("input");
+        expect(inputEl).toEqualAttribute("aria-label", "example label, Upload new document");
+        expect(inputEl).toEqualAttribute("aria-required", "true");
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    required-field="true"
+    ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        inputEl = page.root.shadowRoot.querySelector("input");
+        expect(inputEl).toEqualAttribute("aria-label", "Upload new document");
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    label="Upload new document"
+    required-field="true"
+    ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        inputEl = page.root.shadowRoot.querySelector("input");
+        expect(inputEl).toEqualAttribute("aria-label", "Upload new document");
+    });
+    it("renders button text based on button-text prop", () => {
+        const labelEl = page.root.shadowRoot.querySelector("label");
+        expect(labelEl.textContent).toBe("Upload new document");
+    });
+    it("uploads files", async () => {
+        const input = page.root.shadowRoot.querySelector("input");
+        // fake files which the components uploadFiles() function will process
+        // @ts-ignore
+        input.files = {
+            length: 2,
+            0: {
+                lastModified: 1562163068000,
+                lastModifiedDate: new Date(1562163068000),
+                name: "third_file.pdf",
+                size: 104857600,
+                type: "application/pdf",
+                webkitRelativePath: "",
+            },
+            1: {
+                lastModified: 1562062469000,
+                lastModifiedDate: new Date(1562062469000),
+                name: "fourth file.jpg",
+                size: 123456,
+                type: "image/jpeg",
+                webkitRelativePath: "",
+            },
+        };
+        // triggering the change event will run validations and emit event wmUploaderFilesSelected
+        const ev = new Event("change");
+        let validFiles = [];
+        page.root.addEventListener("wmUploaderFilesSelected", (ev) => (validFiles = ev.detail));
+        input.dispatchEvent(ev);
+        await page.waitForChanges();
+        expect(validFiles[0].name).toBe("third_file.pdf");
+        expect(validFiles[1].size).toBe(123456);
+    });
+    it("disables button when upload is in progress", async () => {
+        html = `<wm-uploader id="uploader1">
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB" progress="30"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        const labelEl = page.root.shadowRoot.querySelector("label");
+        expect(labelEl).toHaveClass("disabled");
+    });
+    it("renders max-files text, if set", async () => {
+        let html, page;
+        html = `<wm-uploader
+      id="uploader1"
+      button-text="Upload new document"
+      ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        let fileCountEl = page.root.shadowRoot.querySelector("#file-count");
+        expect(fileCountEl).toBeFalsy();
+        html = `<wm-uploader
+    id="uploader1"
+    max-files="3"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        fileCountEl = page.root.shadowRoot.querySelector("#file-count");
+        expect(fileCountEl).toBeTruthy();
+        expect(fileCountEl.textContent).toBe("2 of 3 Files");
+    });
+    it("renders max-size text, if set", async () => {
+        let html, page;
+        html = `<wm-uploader
+      id="uploader1"
+      button-text="Upload new document"
+      ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        let maxSizeEl = page.root.shadowRoot.querySelector("#max-size");
+        expect(maxSizeEl).toBeFalsy();
+        html = `<wm-uploader
+      id="uploader1"
+      max-size="25 MB"
+      button-text="Upload new document"
+      ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        maxSizeEl = page.root.shadowRoot.querySelector("#max-size");
+        expect(maxSizeEl).toBeTruthy();
+        expect(maxSizeEl.textContent).toBe("Maximum file size 25 MB");
+    });
+    it("announces error when max-files has been reached and button clicked", async () => {
+        html = `<wm-uploader
+    id="uploader1"
+    max-files="2"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        const input = page.root.shadowRoot.querySelector("input");
+        input.click();
+        await page.waitForChanges();
+        const liveRegion = page.root.shadowRoot.querySelector(".live-region").textContent;
+        expect(liveRegion).toBe("The maximum number of files has been reached");
+    });
+    it("singularizes the accepted file types message", async () => {
+        let message = page.root.shadowRoot.querySelector("#accepted-types").textContent;
+        expect(message).toBe("Accepted file types: .pdf, .txt, .log, .xml, .doc, .docx, .xls, .xlsx, .ppt, .pptx, .gif, .jpg, .jpeg, .png, .csv");
+        html = `<wm-uploader
+      id="uploader1"
+      file-types="jpeg"
+      button-text="Upload new document"
+      files='[{"id": "file1", "name": "File retrieved from server", "type": "pdf", "lastUpdated": "1/28/2020"},{"id": "file2", "name": "Second file", "type": "jpeg", "lastUpdated": "2/14/2019"}]'
+      ></wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        message = page.root.shadowRoot.querySelector("#accepted-types").textContent;
+        expect(message).toBe("Accepted file type: .jpeg");
+    });
+    it("provides wm-files with the proper show-info", async () => {
+        // defaults to time
+        let infoEl = await page.root.querySelector("wm-file").shadowRoot.querySelector(".file-info");
+        expect(infoEl.textContent).toBe("1/28/2020");
+        // size
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    show-info="size"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        infoEl = await page.root.querySelector("wm-file").shadowRoot.querySelector(".file-info");
+        expect(infoEl.textContent).toBe("28 KB");
+        // time
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    show-info="time"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        infoEl = await page.root.querySelector("wm-file").shadowRoot.querySelector(".file-info");
+        expect(infoEl.textContent).toBe("1/28/2020");
+        // none
+        html = `<wm-uploader
+    id="uploader1"
+    button-text="Upload new document"
+    show-info="none"
+    >
+      <wm-file id="file1" name="File retrieved from server" type="pdf" last-updated="1/28/2020" size="28 KB"></wm-file>
+      <wm-file id="file2" name="Second file" type="jpeg" last-updated="2/14/2019" size="3 MB""></wm-file>
+    </wm-uploader>`;
+        page = await newSpecPage({ components: [Uploader, File], html });
+        await page.waitForChanges();
+        infoEl = await page.root.querySelector("wm-file").shadowRoot.querySelector(".file-info");
+        expect(infoEl).toBe(null);
+    });
+});

package/dist/collection/global/functions.spec.js

@@ -0,0 +1,126 @@
+import { csvToArray, getAcceptedMimeTypesList, intl, snakeCaseToCamelCase, getNewIndexToFocus, transposeMatrix, wrapAround, skipByInterval, getSmallestSkipInterval, calcPercentageInRange, } from "./functions";
+describe("Global functions", () => {
+    it("converts the list of extensions into a list of MIME types", () => {
+        expect(getAcceptedMimeTypesList(["pdf", "doc", "txt"])).toMatchObject([
+            "application/pdf",
+            "application/msword",
+            "text/plain",
+        ]);
+    });
+    it("translates", () => {
+        expect(intl.formatMessage({ id: "date.Monday", defaultMessage: "Monday" })).toEqual("Monday"); // falls back to English when language attribute is not set
+    });
+    it("changes string from snake_case to camelCase", async () => {
+        expect(snakeCaseToCamelCase("snake_case")).toBe("snakeCase");
+        expect(snakeCaseToCamelCase("even_more_words")).toBe("evenMoreWords");
+        expect(snakeCaseToCamelCase("camelCase")).toBe("camelCase");
+        expect(snakeCaseToCamelCase("A regular sentence")).toBe("A regular sentence");
+        expect(snakeCaseToCamelCase("singleword")).toBe("singleword");
+    });
+    it("parses comma separated values properly", async () => {
+        expect(csvToArray("one, two, three")).toStrictEqual(["one", "two", "three"]);
+        expect(csvToArray("four,five, six")).toStrictEqual(["four", "five", "six"]);
+        expect(csvToArray("seven eight,nine ten eleven")).toStrictEqual(["seven eight", "nine ten eleven"]);
+    });
+    it("gets new index to focus correctly", async () => {
+        let index = 1;
+        let direction = "ArrowDown";
+        let listLength = 5;
+        // moves forward
+        expect(getNewIndexToFocus(index, direction, listLength)).toBe(index + 1);
+        // wraps backwards
+        index = 4;
+        expect(getNewIndexToFocus(index, direction, listLength)).toBe(0);
+        // moves backwards
+        direction = "ArrowUp";
+        index = 2;
+        expect(getNewIndexToFocus(index, direction, listLength)).toBe(index - 1);
+        // wraps forward
+        index = 0;
+        expect(getNewIndexToFocus(index, direction, listLength)).toBe(listLength - 1);
+    });
+    it("transposes matrices correctly", () => {
+        expect(transposeMatrix([
+            [0, 1, 2],
+            [3, 4, 5],
+            [6, 7, 8],
+        ])).toStrictEqual([
+            [0, 3, 6],
+            [1, 4, 7],
+            [2, 5, 8],
+        ]);
+        expect(transposeMatrix([
+            [0, 1, 2, 3],
+            [4, 5, 6, 7],
+            [8, 9, 10, 11],
+        ])).toStrictEqual([
+            [0, 4, 8],
+            [1, 5, 9],
+            [2, 6, 10],
+            [3, 7, 11],
+        ]);
+        expect(transposeMatrix([
+            ["0", "1", "2"],
+            ["3", "4", "5"],
+            ["6", "7", "8"],
+        ])).toStrictEqual([
+            ["0", "3", "6"],
+            ["1", "4", "7"],
+            ["2", "5", "8"],
+        ]);
+        expect(transposeMatrix([
+            [0, "1", 2],
+            [3, 4, [5]],
+            [{ key: "value" }, 7, 8],
+        ])).toStrictEqual([
+            [0, 3, { key: "value" }],
+            ["1", 4, 7],
+            [2, [5], 8],
+        ]);
+    });
+    it("wraps around indices correctly", () => {
+        // forward steps
+        expect(wrapAround(0, 1, 8)).toBe(1);
+        expect(wrapAround(2, 3, 8)).toBe(5);
+        expect(wrapAround(7, 1, 8)).toBe(8);
+        // forward to 0
+        expect(wrapAround(8, 1, 8)).toBe(0);
+        expect(wrapAround(2, 7, 8)).toBe(0);
+        // forward beyond 0
+        expect(wrapAround(8, 4, 8)).toBe(3);
+        expect(wrapAround(2, 10, 8)).toBe(3);
+        // backward steps
+        expect(wrapAround(8, -1, 8)).toBe(7);
+        expect(wrapAround(5, -3, 8)).toBe(2);
+        expect(wrapAround(1, -1, 8)).toBe(0);
+        // backward to end
+        expect(wrapAround(0, -1, 8)).toBe(8);
+        expect(wrapAround(7, -8, 8)).toBe(8);
+        // backward beyond end
+        expect(wrapAround(0, -7, 8)).toBe(2);
+        expect(wrapAround(2, -7, 8)).toBe(4);
+        // multiple wraps
+        expect(wrapAround(0, 10, 2)).toBe(1);
+        expect(wrapAround(0, -10, 2)).toBe(2);
+    });
+    it("skips by interval correctly", () => {
+        const list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        expect(skipByInterval(list, 0)).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        expect(skipByInterval(list, 1)).toStrictEqual([0, 2, 4, 6, 8]);
+        expect(skipByInterval(list, 2)).toStrictEqual([0, 3, 6, 9]);
+        expect(skipByInterval(list, 3)).toStrictEqual([0, 4, 8]);
+        expect(skipByInterval(list, 4)).toStrictEqual([0, 5]);
+        expect(skipByInterval(list, 5)).toStrictEqual([0, 6]);
+        expect(skipByInterval(list, 20)).toStrictEqual([0]);
+        expect(getSmallestSkipInterval(list, 6)).toStrictEqual({ skipInterval: 1, skippedList: [0, 2, 4, 6, 8] });
+        expect(getSmallestSkipInterval(list, 5)).toStrictEqual({ skipInterval: 1, skippedList: [0, 2, 4, 6, 8] });
+        expect(getSmallestSkipInterval(list, 3)).toStrictEqual({ skipInterval: 3, skippedList: [0, 4, 8] });
+        expect(getSmallestSkipInterval(list, 1)).toStrictEqual({ skipInterval: 9, skippedList: [0] });
+    });
+    it("calcs percentage in range properly", () => {
+        expect(calcPercentageInRange(13, 0, 100)).toBe(13);
+        expect(calcPercentageInRange(-75, -100, 0)).toBe(25);
+        expect(calcPercentageInRange(50, 25, 75)).toBe(50);
+        expect(calcPercentageInRange(150, 100, 300)).toBe(25);
+    });
+});

package/dist/collection/lang/lang.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+const en = require("./en.json");
+const fr = require("./fr.json");
+const es = require("./es.json");
+const pig = require("./pig.json");
+describe("translations", () => {
+    it("has translated strings for every key", () => {
+        let missingFR = [];
+        let missingES = [];
+        let missingPIG = [];
+        for (let i = 0; i < Object.keys(en).length; i++) {
+            !Object.keys(fr).includes(Object.keys(en)[i]) && missingFR.push(Object.keys(en)[i]);
+            !Object.keys(es).includes(Object.keys(en)[i]) && missingES.push(Object.keys(en)[i]);
+            !Object.keys(pig).includes(Object.keys(en)[i]) && missingPIG.push(Object.keys(en)[i]);
+        }
+        expect(missingFR.length).toBe(0);
+        expect(missingES.length).toBe(0);
+        expect(missingPIG.length).toBe(0);
+    });
+});

package/dist/esm/{chartFunctions-da985798.js → chartFunctions-036fdb89.js}

@@ -1,5 +1,5 @@
-import { h } from './index-130e07bb.js';
-import { i as intl, c as safeMultiplyFloat, e as getPosition, f as checkForActiveElInShadow } from './functions-25781571.js';
+import { h } from './index-558b5a82.js';
+import { i as intl, c as safeMultiplyFloat, e as getPosition, f as checkForActiveElInShadow } from './functions-46843ea0.js';
 
 const colors = {
     salmon: "#ff5f4e",
@@ -84,7 +84,7 @@ const allChartsDetails = {
     bar5: {
         size: 400,
         colors: [
-            colors.gray, // this is only used if prop notStartedColor is set
+            colors.gray,
             colors.lavender,
             colors.midnight,
             "#0089e4",

package/dist/esm/{functions-25781571.js → functions-46843ea0.js}

@@ -3088,7 +3088,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
@@ -3344,7 +3344,7 @@ function parseDateTimeSkeleton(skeleton) {
                 throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');
             // Weekday
             case 'E':
-                result.weekday = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
+                result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';
                 break;
             case 'e':
                 if (len < 4) {
@@ -3402,7 +3402,7 @@ function parseDateTimeSkeleton(skeleton) {
                 result.timeZoneName = len < 4 ? 'short' : 'long';
                 break;
             case 'Z': // 1..3, 4, 5: The ISO8601 varios formats
-            case 'O': // 1, 4: milliseconds in day short, long
+            case 'O': // 1, 4: miliseconds in day short, long
             case 'v': // 1, 4: generic non-location format
             case 'V': // 1, 2, 3, 4: time zone ID or city
             case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
@@ -3633,27 +3633,6 @@ function parseNumberSkeleton(tokens) {
             case 'scale':
                 result.scale = parseFloat(token.options[0]);
                 continue;
-            case 'rounding-mode-floor':
-                result.roundingMode = 'floor';
-                continue;
-            case 'rounding-mode-ceiling':
-                result.roundingMode = 'ceil';
-                continue;
-            case 'rounding-mode-down':
-                result.roundingMode = 'trunc';
-                continue;
-            case 'rounding-mode-up':
-                result.roundingMode = 'expand';
-                continue;
-            case 'rounding-mode-half-even':
-                result.roundingMode = 'halfEven';
-                continue;
-            case 'rounding-mode-half-down':
-                result.roundingMode = 'halfTrunc';
-                continue;
-            case 'rounding-mode-half-up':
-                result.roundingMode = 'halfExpand';
-                continue;
             // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
             case 'integer-width':
                 if (token.options.length > 1) {
@@ -3853,10 +3832,6 @@ var timeData = {
         "hb",
         "H"
     ],
-    "BI": [
-        "H",
-        "h"
-    ],
     "BJ": [
         "H",
         "hB"
@@ -3906,10 +3881,6 @@ var timeData = {
         "hb",
         "hB"
     ],
-    "BY": [
-        "H",
-        "h"
-    ],
     "BZ": [
         "H",
         "h",
@@ -3998,10 +3969,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "CW": [
-        "H",
-        "hB"
-    ],
     "CX": [
         "H",
         "h",
@@ -4117,10 +4084,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "FO": [
-        "H",
-        "h"
-    ],
     "FR": [
         "H",
         "hB"
@@ -4166,10 +4129,6 @@ var timeData = {
         "hb",
         "hB"
     ],
-    "GL": [
-        "H",
-        "h"
-    ],
     "GM": [
         "h",
         "hb",
@@ -4234,10 +4193,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "HU": [
-        "H",
-        "h"
-    ],
     "IC": [
         "H",
         "h",
@@ -4310,8 +4265,8 @@ var timeData = {
     ],
     "JP": [
         "H",
-        "K",
-        "h"
+        "h",
+        "K"
     ],
     "KE": [
         "hB",
@@ -4462,10 +4417,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "MG": [
-        "H",
-        "h"
-    ],
     "MH": [
         "h",
         "hb",
@@ -4521,18 +4472,6 @@ var timeData = {
         "hb",
         "hB"
     ],
-    "MT": [
-        "H",
-        "h"
-    ],
-    "MU": [
-        "H",
-        "h"
-    ],
-    "MV": [
-        "H",
-        "h"
-    ],
     "MW": [
         "h",
         "hb",
@@ -4590,10 +4529,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "NO": [
-        "H",
-        "h"
-    ],
     "NP": [
         "H",
         "h",
@@ -4655,10 +4590,6 @@ var timeData = {
         "hB",
         "H"
     ],
-    "PL": [
-        "H",
-        "h"
-    ],
     "PM": [
         "H",
         "hB"
@@ -4717,10 +4648,6 @@ var timeData = {
     "RU": [
         "H"
     ],
-    "RW": [
-        "H",
-        "h"
-    ],
     "SA": [
         "h",
         "hB",
@@ -4853,24 +4780,12 @@ var timeData = {
         "H",
         "hB"
     ],
-    "TH": [
-        "H",
-        "h"
-    ],
-    "TJ": [
-        "H",
-        "h"
-    ],
     "TL": [
         "H",
         "hB",
         "hb",
         "h"
     ],
-    "TM": [
-        "H",
-        "h"
-    ],
     "TN": [
         "h",
         "hB",
@@ -4966,10 +4881,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "VN": [
-        "H",
-        "h"
-    ],
     "VU": [
         "h",
         "H"
@@ -5009,10 +4920,6 @@ var timeData = {
         "H",
         "hB"
     ],
-    "ZW": [
-        "H",
-        "h"
-    ],
     "af-ZA": [
         "H",
         "h",
@@ -6916,8 +6823,8 @@ function createDefaultFormatters(cache) {
 }
 var IntlMessageFormat = /** @class */ (function () {
     function IntlMessageFormat(message, locales, overrideFormats, opts) {
-        var _this = this;
         if (locales === void 0) { locales = IntlMessageFormat.defaultLocale; }
+        var _this = this;
         this.formatterCache = {
             number: {},
             dateTime: {},
@@ -7654,6 +7561,7 @@ function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options)
 var NUMBER_FORMAT_OPTIONS = [
     'style',
     'currency',
+    'currencyDisplay',
     'unit',
     'unitDisplay',
     'useGrouping',
@@ -7671,11 +7579,6 @@ var NUMBER_FORMAT_OPTIONS = [
     'unit',
     'unitDisplay',
     'numberingSystem',
-    // ES2023 NumberFormat
-    'trailingZeroDisplay',
-    'roundingPriority',
-    'roundingIncrement',
-    'roundingMode',
 ];
 function getFormatter(_a, getNumberFormat, options) {
     var locale = _a.locale, formats = _a.formats, onError = _a.onError;
@@ -8414,4 +8317,4 @@ const weekdays = [
     intl.formatMessage({ id: "date.saturday", defaultMessage: "Saturday" }),
 ];
 
-export { getContextMeasurements as A, dateFind as B, calendar_months as C, findParentWithHiddenOverflow as D, transposeMatrix as E, wrapAround as F, getSmallestSkipInterval as G, calcPercentageInRange as H, makeISO as I, getMonthLength as J, weekdays as K, findParentWithScrollbar as L, handleDisabledAttribute as a, triggerFormSubmit as b, safeMultiplyFloat as c, debounce as d, getPosition as e, checkForActiveElInShadow as f, generateId as g, hideTooltip as h, intl as i, dateToISO as j, shouldOpenUp as k, hasRoomRight as l, truncateText as m, snakeCaseToCamelCase as n, getNewIndexToFocus as o, shouldOpenDown as p, shouldShiftRight as q, shouldShiftLeft as r, showTooltip as s, toBool as t, measureText as u, findNext as v, findPrev as w, csvToArray as x, getTextDir as y, throttle as z };
+export { getContextMeasurements as A, dateFind as B, calendar_months as C, findParentWithHiddenOverflow as D, transposeMatrix as E, wrapAround as F, getSmallestSkipInterval as G, calcPercentageInRange as H, makeISO as I, weekdays as J, getMonthLength as K, findParentWithScrollbar as L, handleDisabledAttribute as a, triggerFormSubmit as b, safeMultiplyFloat as c, debounce as d, getPosition as e, checkForActiveElInShadow as f, generateId as g, hideTooltip as h, intl as i, dateToISO as j, shouldOpenUp as k, hasRoomRight as l, truncateText as m, snakeCaseToCamelCase as n, getNewIndexToFocus as o, shouldOpenDown as p, shouldShiftRight as q, shouldShiftLeft as r, showTooltip as s, toBool as t, measureText as u, findNext as v, findPrev as w, csvToArray as x, getTextDir as y, throttle as z };