npm - @qualified-salesforce/web - Versions diffs - 0.0.1-oidc-bootstrap - Mend

@qualified-salesforce/web 0.0.1-oidc-bootstrap

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (560) hide show

package/src/proxy.js ADDED Viewed

@@ -0,0 +1,144 @@
+import { _extends } from "../js/4101.js";
+/**
+ * Property patching that stays reversible: replace a property on any object
+ * and keep reading what was there before.
+ *
+ * Docking is the heaviest user — it rewrites what the host page observes, so
+ * `window.innerWidth` reports the constrained content area and
+ * `document.documentElement.scrollTop` reads through `<body>` — while some of
+ * our own code still needs the browser's real value (the liveview shipper must
+ * send the true viewport size or the receiver applies the docked shrink a
+ * second time).
+ *
+ * Every patch installed through {@link applyProxy} saves the descriptor it
+ * replaced, and {@link originalOf} exposes the target as it was before we
+ * touched it. The alternative — reading a second, un-patched source for the
+ * same value — drifts: `visualViewport` can itself be patched by another
+ * integration, and a snapshot taken at startup goes stale on the first resize.
+ * A saved descriptor is the accessor the browser installed, so it stays
+ * correct for the lifetime of the page.
+ */
+/** Non-enumerable own property holding the read-only pre-patch view. */ const ORIGINAL_KEY = "__q_proxy_original";
+/** Non-enumerable own property holding the descriptors we replaced. */ const SAVED_KEY = "__q_proxy_saved";
+function isProxied(target) {
+    return Object.prototype.hasOwnProperty.call(target, ORIGINAL_KEY);
+}
+/**
+ * Attaches the (initially empty) bookkeeping to `target` and returns it.
+ * Idempotent — a target that already carries the bookkeeping keeps the
+ * descriptors saved by earlier patches.
+ */ function initProxy(target) {
+    if (isProxied(target)) return target;
+    const saved = new Map();
+    // A saved `undefined` means the property had no own descriptor before we
+    // patched it, so the pre-patch value lives on the prototype chain —
+    // `innerWidth` is an accessor on `Window.prototype`, not an own property of
+    // the window. Native accessors brand-check their receiver, so these resolve
+    // against the real object rather than the proxy (which would throw "Illegal
+    // invocation"); reading the raw value is the point anyway.
+    const fromPrototype = (obj, key)=>{
+        const proto = Reflect.getPrototypeOf(obj);
+        return proto ? Reflect.get(proto, key, obj) : undefined;
+    };
+    const original = new Proxy(target, {
+        get (obj, key) {
+            if (!saved.has(key)) return Reflect.get(obj, key);
+            const descriptor = saved.get(key);
+            if (!descriptor) return fromPrototype(obj, key);
+            return descriptor.get ? descriptor.get.call(obj) : descriptor.value;
+        },
+        // Read-only view: writes belong on the target itself, where the patched
+        // property (and therefore the host page) can see them.
+        set () {
+            return false;
+        },
+        has (obj, key) {
+            if (!saved.has(key)) return Reflect.has(obj, key);
+            if (saved.get(key)) return true;
+            const proto = Reflect.getPrototypeOf(obj);
+            return proto ? Reflect.has(proto, key) : false;
+        },
+        getOwnPropertyDescriptor (obj, key) {
+            if (!saved.has(key)) return Reflect.getOwnPropertyDescriptor(obj, key);
+            const descriptor = saved.get(key);
+            // Every property we patch is defined as configurable, so reporting the
+            // saved descriptor as configurable keeps the proxy invariants satisfied.
+            return descriptor && _extends({}, descriptor, {
+                configurable: true
+            });
+        }
+    });
+    Object.defineProperty(target, SAVED_KEY, {
+        value: saved,
+        enumerable: false,
+        writable: false,
+        configurable: true
+    });
+    Object.defineProperty(target, ORIGINAL_KEY, {
+        value: original,
+        enumerable: false,
+        writable: false,
+        configurable: true
+    });
+    return target;
+}
+/**
+ * Defines `key` on `target` (always configurable, so a later patch or a restore
+ * can replace it) and records the descriptor it replaced.
+ *
+ * Best-effort by design, because the objects worth patching are the ones we
+ * don't control: a property the browser refuses to redefine — or a target that
+ * refuses the bookkeeping at all — is left as it was and nothing is recorded for
+ * it, so {@link originalOf} keeps reading its live value either way.
+ */ function applyProxy(target, key, descriptor) {
+    // Installing the bookkeeping defines properties on the target, which a non-extensible host
+    // object refuses. That is the same "we don't control this object" case the patch itself is
+    // tolerant of, so it takes the same no-op path instead of aborting docking setup.
+    let proxied;
+    try {
+        proxied = initProxy(target);
+    } catch (unused) {
+        return target;
+    }
+    const replaced = Reflect.getOwnPropertyDescriptor(target, key);
+    try {
+        // `configurable` is forced last: a caller descriptor that pinned it to false would make the
+        // patched property non-configurable, and the original view reports saved descriptors as
+        // configurable (and returns the pre-patch value) — which the proxy invariants would then
+        // reject with a TypeError on the first read.
+        Object.defineProperty(target, key, _extends({}, descriptor, {
+            configurable: true
+        }));
+    } catch (unused) {
+        return proxied;
+    }
+    // Record only the first patch, so re-patching a property (or a second caller
+    // patching one we already own) still resolves to the pre-patch value.
+    const saved = proxied[SAVED_KEY];
+    if (!saved.has(key)) saved.set(key, replaced);
+    return proxied;
+}
+/**
+ * Read-only view of `target` as it was before {@link applyProxy} patched it.
+ * Properties nothing patched read straight through, so the view works as a
+ * general accessor — including on pages where no patch was ever installed, where
+ * it hands back the target itself rather than installing bookkeeping on an
+ * object we were only asked to read from.
+ *
+ * Read at the point of use rather than captured up front, since a view taken
+ * before the first patch is the bare target and won't look behind later ones.
+ *
+ * `Readonly` is the whole contract, and it is shallow: the proxy refuses writes
+ * (its `set` trap throws) but the bare target doesn't, and nested objects
+ * reached either way are the real ones. Writes belong on the target, where the
+ * patched property — and therefore the host page — can see them.
+ *
+ * Methods resolved through it are unbound (a plain `Reflect.get`), so call them
+ * against the target: `originalOf(win).matchMedia.call(win, query)`.
+ */ function originalOf(target) {
+    return isProxied(target) ? target[ORIGINAL_KEY] : target;
+}
+var proxy_initProxy = /* unused export */ undefined;
+export { applyProxy, originalOf, proxy_initProxy as initProxy };

package/src/qualified_root.js ADDED Viewed

@@ -0,0 +1,35 @@
+import { defineSingletonHost } from "./singleton_host.js";
+/** Tag name of the singleton root element. */ const QUALIFIED_ROOT_TAG_NAME = "q-root";
+/**
+ * `<q-root>` — the one place everything Qualified injects into a customer page
+ * hangs off of. Purely a grouping element: a stable parent to append to, and a
+ * single selector for page-scanning code to skip.
+ *
+ * Boxless, so it neither becomes a stacking context that would swallow customer
+ * overrides like `#qualified-multimodal-host { z-index: 999 }`, nor a containing
+ * block its `position: fixed` occupants resolve against. No shadow root either,
+ * so children stay reachable from the docking pack's `html[q-docked]` rules.
+ */ class QRootElement extends HTMLElement {
+    // Not the constructor, which may not touch attributes. Re-runs on every move,
+    // so an adopted root that lost its style is dressed again.
+    connectedCallback() {
+        this.style.cssText = "display:contents";
+    }
+}
+const findQualifiedRoot = defineSingletonHost(QUALIFIED_ROOT_TAG_NAME, QRootElement);
+/**
+ * Returns the singleton `<q-root>`, creating it under `<html>` on first call.
+ */ function getQualifiedRoot() {
+    const root = findQualifiedRoot();
+    // Under `<html>`: a page may replace `<body>` wholesale on navigation, and
+    // docking runs before `<body>` exists.
+    if (root.parentNode !== document.documentElement) {
+        document.documentElement.appendChild(root);
+    }
+    return root;
+}
+var qualified_root_QUALIFIED_ROOT_TAG_NAME = /* unused export */ undefined;
+export { getQualifiedRoot, qualified_root_QUALIFIED_ROOT_TAG_NAME as QUALIFIED_ROOT_TAG_NAME };

package/src/query_params.js ADDED Viewed

@@ -0,0 +1,55 @@
+const coercions = {
+    string: (v)=>v,
+    number: (v)=>{
+        const n = Number(v);
+        return Number.isNaN(n) ? undefined : n;
+    },
+    boolean: (v)=>{
+        if (v === "1" || v === "true") return true;
+        if (v === "0" || v === "false") return false;
+        return undefined;
+    },
+    enum: (v, param)=>{
+        let { allowed, aliases } = param;
+        var _ref;
+        const value = (_ref = aliases == null ? void 0 : aliases[v]) != null ? _ref : v;
+        if (!(allowed == null ? void 0 : allowed.includes(value))) return undefined;
+        return value;
+    }
+};
+function coerceParts(parts, params) {
+    const results = [];
+    for(let i = 0; i < parts.length && i < params.length; i++){
+        const raw = parts[i];
+        const param = params[i];
+        if (!raw) {
+            continue;
+        }
+        const coerced = coercions[param.type](raw, param);
+        if (coerced !== undefined) {
+            results.push({
+                name: param.name,
+                value: coerced
+            });
+        }
+    }
+    return results;
+}
+function parseQueryParams(value, schema) {
+    if (!value) return schema.dict ? {} : [];
+    const parts = value.split(",");
+    const coerced = coerceParts(parts, schema.params);
+    if (schema.dict) {
+        const result = {};
+        for (const { name, value: val } of coerced){
+            result[name] = val;
+        }
+        return result;
+    }
+    return coerced.map((param)=>{
+        let { value: val } = param;
+        return val;
+    });
+}
+export { parseQueryParams };

package/src/shadow-dom-helper.js ADDED Viewed

@@ -0,0 +1,63 @@
+import { _extends } from "../js/4101.js";
+const defaultOptions = {
+    memoizeShadowRoots: true,
+    shadowHostSelectorFilter: "*"
+};
+class ShadowDomHelper {
+    /**
+   * Get all shadow roots in the document.
+   */ get shadowRoots() {
+        if (this.options.memoizeShadowRoots) {
+            var _this__shadowRoots;
+            return (_this__shadowRoots = this._shadowRoots) != null ? _this__shadowRoots : this._shadowRoots = this.getShadowRoots();
+        }
+        return this.getShadowRoots();
+    }
+    /**
+   * Get the first element in the document that matches the selector.
+   * Includes elements in shadow roots.
+   */ querySelector(selector) {
+        let element = document.querySelector(selector);
+        if (element) return element;
+        for (const shadowRoot of this.shadowRoots){
+            element = shadowRoot.querySelector(selector);
+            if (element) return element;
+        }
+        return null;
+    }
+    /**
+   * Get all elements in the document that match the selector.
+   * Includes elements in shadow roots.
+   */ querySelectorAll(selector) {
+        const elementLists = [
+            document.querySelectorAll(selector)
+        ];
+        for (const shadowRoot of this.shadowRoots){
+            elementLists.push(shadowRoot.querySelectorAll(selector));
+        }
+        const elements = [];
+        for (const elementList of elementLists){
+            elements.push(...elementList);
+        }
+        return elements;
+    }
+    getShadowRoots(root, set) {
+        if (root === void 0) root = document;
+        if (set === void 0) set = new Set();
+        root.querySelectorAll(this.options.shadowHostSelectorFilter).forEach((el)=>{
+            if (el.shadowRoot) {
+                set.add(el.shadowRoot);
+                this.getShadowRoots(el.shadowRoot, set);
+            }
+        });
+        return set;
+    }
+    constructor(options = {}){
+        this._shadowRoots = null;
+        this.options = _extends({}, defaultOptions, options);
+    }
+}
+export { ShadowDomHelper };

package/src/singleton_host.js ADDED Viewed

@@ -0,0 +1,39 @@
+/**
+ * Create/adopt lifecycle for the singleton custom elements Qualified injects
+ * into a customer page. Under `src/`, the only import root the docking pack and
+ * the widget bundle share.
+ */ /** Marks a host as ours, so adoption skips elements that share the tag. */ const SINGLETON_HOST_ATTRIBUTE = "data-q-host";
+/**
+ * Builds the getter for a singleton host: registers `elementClass` if the tag is
+ * free, adopts a marked element already in the DOM, caches what it settles on.
+ * Mounting stays with the caller, setup with the element's own lifecycle.
+ *
+ * Adoption is a supported path, not a fallback: whichever bundle loads second
+ * finds the tag taken and an equivalent element in the DOM.
+ */ function defineSingletonHost(tagName, elementClass) {
+    let cached = null;
+    return function getSingletonHost() {
+        // Trusted even while detached: the caller re-parents what it gets, and
+        // rebuilding would strand shadow roots nothing else rebuilds.
+        if (cached) return cached;
+        if (!customElements.get(tagName)) {
+            try {
+                customElements.define(tagName, elementClass);
+            } catch (unused) {
+            // Tag already claimed; take whatever that registration produces.
+            }
+        }
+        const existing = document.querySelector(tagName + "[" + SINGLETON_HOST_ATTRIBUTE + "]");
+        if (existing instanceof HTMLElement) {
+            cached = existing;
+            return cached;
+        }
+        // Still whatever the registration produces; the mark only claims it as ours.
+        cached = document.createElement(tagName);
+        cached.setAttribute(SINGLETON_HOST_ATTRIBUTE, "");
+        return cached;
+    };
+}
+var singleton_host_SINGLETON_HOST_ATTRIBUTE = /* unused export */ undefined;
+export { defineSingletonHost, singleton_host_SINGLETON_HOST_ATTRIBUTE as SINGLETON_HOST_ATTRIBUTE };

package/src/smart_website/trigger.js ADDED Viewed

@@ -0,0 +1,49 @@
+import { extractTextContentSelector, extractHrefSelector } from "./utils.js";
+class Trigger {
+    get textContent() {
+        return extractTextContentSelector(this.selector);
+    }
+    get href() {
+        return extractHrefSelector(this.selector);
+    }
+    get isLegacyTrigger() {
+        return this.legacy;
+    }
+    // 1. just this button on this page
+    // 2. just this button across site
+    // 3. any button on this page that links to
+    // 4. any button on this page that says
+    // 5. any button on the entire site that links to
+    // 6. any button on the entire site that says
+    // Leave gaps in numbering for ease of extensibility to this ranking
+    get scopePrecedence() {
+        // legacy manual triggers always ranked last
+        if (this.legacy) return 100;
+        if (this.textContent === undefined && this.href === undefined && !this.global) {
+            return 10;
+        } else if (this.textContent === undefined && this.href === undefined && this.global) {
+            return 20;
+        } else if (this.href !== undefined && !this.global) {
+            return 30;
+        } else if (this.textContent !== undefined && !this.global) {
+            return 40;
+        } else if (this.href !== undefined && this.global) {
+            return 50;
+        } else if (this.textContent !== undefined && this.global) {
+            return 60;
+        } else {
+            return 99;
+        }
+    }
+    constructor(props){
+        this.url = props.url;
+        this.selector = props.selector;
+        this.api = props.api;
+        this.global = props.global;
+        this.legacy = props.legacy;
+    }
+}
+export { Trigger };

package/src/smart_website/utils.js ADDED Viewed

@@ -0,0 +1,149 @@
+import "../../js/4101.js";
+const SWB_DATA_ATTRS = (/* unused pure expression or super */ null && ({
+    container: "data-qualified-container",
+    pickable: "data-qualified-pickable",
+    selected: "data-qualified-selector",
+    activeSelected: "data-qualified-active-selector",
+    invalidSelected: "data-qualified-invalid-selector",
+    invalidPickable: "data-qualified-invalid-pickable"
+}));
+const SWB_URL = "swb_url";
+const BUTTON_LIKE_SELECTOR = "a, button, .btn, [role=button], input[type=button], input[type=submit]";
+const FINDER_SETTINGS = (root)=>({
+        /**
+   * Root of search, defaults to document.body.
+   */ root,
+        /**
+   * Function to check if this ID can be used.
+   */ idName: (_name)=>true,
+        /**
+   * Function to check if this class name can be used.
+   */ className: (_name)=>true,
+        /**
+   * Function to check if tag name can be used.
+   */ tagName: (_name)=>true,
+        /**
+   * Function to check if attr name can be used. Don't rely on attributes because it makes
+   * the setup too brittle. We might consider making this a team level configuration in the future.
+   */ attr: (_name, _value)=>false,
+        /**
+   * Minimum length of levels in fining selector. Starts from 1.
+   * For more robust selectors give this param value around 4-5 depending on depth of you DOM tree.
+   * If finder hits the root, this param is ignored.
+   * */ seedMinLength: 5,
+        /**
+   * Minimum length for optimising selector. Starts from 2.
+   * For example selector body > div > div > p can be optimised to body p.
+   */ optimizedMinLength: 2,
+        /**
+   * Max number of selectors to check before falling into nth-child usage.
+   * Checking for uniqueness of selector is very costly operation,
+   * if you have DOM tree depth of 5, with 5 classes on each level,
+   * that gives you more than 3k selectors to check.
+   * Default 1000 is good enough in most cases.
+   */ threshold: 1000,
+        /**
+   * Max number of tries for the optimization.
+   * This is a trade-off between optimization and efficiency.
+   * Default 10_000 is good enough in most cases.
+   */ maxNumberOfTries: 10000
+    });
+const SELECTOR_REGEXES = {
+    href: /\[href="([^"]+)"\]/,
+    text: /a:contains\("([^"]+)"\)/
+};
+const extractTextContentSelector = (selector)=>{
+    var _selector_match;
+    return (_selector_match = selector.match(SELECTOR_REGEXES.text)) == null ? void 0 : _selector_match[1];
+};
+const extractHrefSelector = (selector)=>{
+    var _selector_match;
+    return (_selector_match = selector.match(SELECTOR_REGEXES.href)) == null ? void 0 : _selector_match[1];
+};
+const matchesTextContent = (tag, textContent)=>{
+    var _tag_textContent_trim_toLowerCase, _tag_textContent_trim, _tag_textContent;
+    // Remove "&nbsp;" chars from tag.textContent, since it's visually identical to " " (space)
+    const tagContentWithoutNbsp = (_tag_textContent = tag.textContent) == null ? void 0 : (_tag_textContent_trim = _tag_textContent.trim()) == null ? void 0 : (_tag_textContent_trim_toLowerCase = _tag_textContent_trim.toLowerCase()) == null ? void 0 : _tag_textContent_trim_toLowerCase.replaceAll(/\xA0/g, " ");
+    return tagContentWithoutNbsp === textContent.toLowerCase();
+};
+const matchesSelector = (target, selector)=>{
+    const keySelector = selector + ", " + selector + " *";
+    const matchResult = target.matches(keySelector);
+    return matchResult;
+};
+/**
+ * NOTE: visitor/snippet-side code should _not_ use this function or `finder` to detect selectors
+ * @param element
+ * @returns CSS selector
+ */ const guessSelector = (element, root)=>{
+    if (root === void 0) root = document.body;
+    try {
+        return finder(element, FINDER_SETTINGS(root));
+    } catch (e) {
+        // eslint-disable-next-line no-console
+        console.error("Qualified: Error finding css selector of " + element.outerHTML + ": " + e);
+        return null;
+    }
+};
+// 1. just this button on this page
+// 2. just this button across site
+// 3. any button on this page that links to
+// 4. any button on this page that says
+// 5. any button on the entire site that links to
+// 6. any button on the entire site that says
+const triggerPrecedenceFn = (a, b)=>{
+    if (a.scopePrecedence < b.scopePrecedence) {
+        return -1;
+    } else if (a.scopePrecedence === b.scopePrecedence) {
+        return 0;
+    } else {
+        return 1;
+    }
+};
+const sortTriggers = (triggers)=>triggers.sort((a, b)=>triggerPrecedenceFn(a, b));
+const isMatchingSelector = (target, selector)=>{
+    const textContent = extractTextContentSelector(selector);
+    return textContent ? matchesTextContent(target, textContent) : matchesSelector(target, selector);
+};
+const Q_DEBUG = "q_debug";
+const isDebugMode = ()=>{
+    return new URLSearchParams(document.location.search).has(Q_DEBUG);
+};
+/**
+ * Note that this cannot be used inside the SWB child iframe since you can't access query params of a parent frame
+ */ const _debugLog = (msg, context)=>{
+    if (context === void 0) context = {};
+    try {
+        if (isDebugMode()) {
+            const prefix = Object.keys(context).length > 0 ? "[" + Object.entries(context).map((param)=>{
+                let [key, value] = param;
+                return key + "=" + value;
+            }).join(" ") + "] " : "";
+            // eslint-disable-next-line no-console
+            console.log("" + prefix + msg);
+        }
+    } catch (e) {
+        // eslint-disable-next-line no-console
+        console.error(e);
+    }
+};
+/**
+ * Checks if the element is within a qualified element.
+ * Qualified elements are:
+ * - Qualified forms
+ * - Website offers
+ * - Multimodal host
+ */ function isWithinQualifiedElement(element) {
+    return element.matches(":is(qualified-form, [data-qualified-offer-host-location], #qualified-multimodal-host) *");
+}
+var utils_Q_DEBUG = /* unused export */ undefined;
+var utils_SELECTOR_REGEXES = /* unused export */ undefined;
+var utils_SWB_DATA_ATTRS = /* unused export */ undefined;
+var utils_SWB_URL = /* unused export */ undefined;
+var utils_guessSelector = /* unused export */ undefined;
+var utils_matchesSelector = /* unused export */ undefined;
+var utils_matchesTextContent = /* unused export */ undefined;
+export { BUTTON_LIKE_SELECTOR, _debugLog, extractHrefSelector, extractTextContentSelector, isDebugMode, isMatchingSelector, isWithinQualifiedElement, sortTriggers, utils_Q_DEBUG as Q_DEBUG, utils_SELECTOR_REGEXES as SELECTOR_REGEXES, utils_SWB_DATA_ATTRS as SWB_DATA_ATTRS, utils_SWB_URL as SWB_URL, utils_guessSelector as guessSelector, utils_matchesSelector as matchesSelector, utils_matchesTextContent as matchesTextContent };

package/src/string.js ADDED Viewed

@@ -0,0 +1,53 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import "../js/4101.js";
+__webpack_require__("98688");
+// "string" to "String"
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+// Given string is a singular noun, returns the plural form if `n` !== 1
+//
+function pluralize(str, n) {
+    if (n === undefined || n !== 1) {
+        if (str.lastIndexOf("s") === str.length - 1) {
+            return "" + str + "es";
+        } else if (str.match(/.+[^aeiou]y$/)) {
+            return "" + str.slice(0, -1) + "ies";
+        } else {
+            return "" + str + "s";
+        }
+    } else {
+        return str;
+    }
+}
+// "Hello World" to "hello-world"
+function kebabify(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function humanize(str) {
+    return capitalize(str.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase());
+}
+function toBase64(str) {
+    return btoa(unescape(encodeURIComponent(str)));
+}
+function fromBase64(str) {
+    return decodeURIComponent(escape(atob(str)));
+}
+// "hello-world" or "helloWorld" to "Hello World"
+function titleize(str) {
+    return str.split(/[\s_]|(?=[A-Z])/g).map((w)=>capitalize(w)).join(" ");
+}
+// Checks if two string arrays are equivalent, ignoring element order.
+function areStringArraysEquivalent(arr1, arr2) {
+    return arr1.length === arr2.length && _isEqual(arr1.sort(), arr2.sort());
+}
+var string_areStringArraysEquivalent = /* unused export */ undefined;
+var string_capitalize = /* unused export */ undefined;
+var string_humanize = /* unused export */ undefined;
+var string_kebabify = /* unused export */ undefined;
+var string_pluralize = /* unused export */ undefined;
+var string_titleize = /* unused export */ undefined;
+export { fromBase64, string_areStringArraysEquivalent as areStringArraysEquivalent, string_capitalize as capitalize, string_humanize as humanize, string_kebabify as kebabify, string_pluralize as pluralize, string_titleize as titleize, toBase64 };

package/src/timezone.js ADDED Viewed

@@ -0,0 +1,57 @@
+function browserIntlSupport() {
+    try {
+        Intl;
+    } catch (e) {
+        return 0;
+    }
+    try {
+        Intl.DateTimeFormat();
+    } catch (e) {
+        return 1;
+    }
+    try {
+        Intl.DateTimeFormat().resolvedOptions();
+    } catch (e) {
+        return 2;
+    }
+    try {
+        Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch (e) {
+        return 3;
+    }
+    const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (zone && zone.length > 3) {
+        return 5;
+    }
+    return 4;
+}
+function guessTimeZone() {
+    try {
+        const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        // Filter out some non-sensical values. https://github.com/moment/moment-timezone/issues/423
+        // (Note not using moment-timezone here cause it's huge, >200k)
+        if (zone && zone.length > 3) {
+            return zone;
+        }
+    } catch (e) {
+    // Browser doesn't have Intl, nbd
+    }
+}
+function getLocalTimeZoneShort() {
+    try {
+        const formatter = new Intl.DateTimeFormat(undefined, {
+            timeZoneName: "short"
+        }), parts = formatter.formatToParts(Date.now()), tzPart = parts.find((param)=>{
+            let { type } = param;
+            return type === "timeZoneName";
+        });
+        if (tzPart) {
+            return tzPart.value;
+        }
+    } catch (e) {
+    // Browser doesn't have Intl, nbd
+    }
+}
+var timezone_getLocalTimeZoneShort = /* unused export */ undefined;
+export { browserIntlSupport, guessTimeZone, timezone_getLocalTimeZoneShort as getLocalTimeZoneShort };