native-fn 1.3.0 → 1.3.1

package/dist/native.mjs

@@ -1,4 +1,4 @@
-var version = "1.3.0";
+var version = "1.3.1";
 var packageJSON = {
 	version: version};
 
@@ -403,9 +403,12 @@ var EventListener = {
 
 var currentUserAgent = USER_AGENT;
 var parsedCache = null;
-var parsedFromHighEntropyValuesOS = {};
-var parsedFromHighEntropyValuesBrowser = {};
-var parsedFromHighEntropyValuesEngine = {};
+var parsedFromHighEntropyValuesOSName = undefined;
+var parsedFromHighEntropyValuesOSVersion = undefined;
+var parsedFromHighEntropyValuesBrowserName = undefined;
+var parsedFromHighEntropyValuesBrowserVersion = undefined;
+var parsedFromHighEntropyValuesEngineName = undefined;
+var parsedFromHighEntropyValuesEngineVersion = undefined;
 var parsedFromHighEntropyValuesDevice = null;
 var parsedFromNavigatorGPU = {};
 var cachedLocale = null;
@@ -452,9 +455,12 @@ function normalizeLocale(locale) {
 function invalidateCache() {
     parsedCache = null;
     cachedLocale = null;
-    parsedFromHighEntropyValuesOS = {};
-    parsedFromHighEntropyValuesBrowser = {};
-    parsedFromHighEntropyValuesEngine = {};
+    parsedFromHighEntropyValuesOSName = undefined;
+    parsedFromHighEntropyValuesOSVersion = undefined;
+    parsedFromHighEntropyValuesBrowserName = undefined;
+    parsedFromHighEntropyValuesBrowserVersion = undefined;
+    parsedFromHighEntropyValuesEngineName = undefined;
+    parsedFromHighEntropyValuesEngineVersion = undefined;
     parsedFromHighEntropyValuesDevice = null;
     parsedFromNavigatorGPU = {};
 }
@@ -470,71 +476,74 @@ function getParsedCache() {
     return parsedCache;
 }
 function parseOS() {
-    var result = { name: OS.Unknown, version: '' };
+    var name = OS.Unknown;
+    var version = '';
     for (var i = 0; i < OS_RESOLVER_MAP.length; i++) {
         var map = OS_RESOLVER_MAP[i];
         var matched = currentUserAgent.match(map[0]);
         if (matched !== null) {
-            result.name = map[1];
-            result.version = resolveVersion(matched[1], map[2]);
+            name = map[1];
+            version = resolveVersion(matched[1], map[2]);
             break;
         }
     }
-    if (result.name === OS.iOS && compareVersion(result.version, '18.6') === 0) {
-        var version = /\) Version\/([\d.]+)/.exec(currentUserAgent);
-        if (version !== null) {
-            var major = parseInt(version[1].split('.')[0], 10);
+    if (name === OS.iOS && compareVersion(version, '18.6') === 0) {
+        var execs = /\) Version\/([\d.]+)/.exec(currentUserAgent);
+        if (execs !== null) {
+            var major = parseInt(execs[1].split('.')[0], 10);
             if (major >= 26)
-                result.version = version[1];
+                version = execs[1];
         }
     }
     if (currentUserAgent === USER_AGENT) {
-        if (typeof parsedFromHighEntropyValuesOS.name !== 'undefined')
-            result.name = parsedFromHighEntropyValuesOS.name;
-        if (typeof parsedFromHighEntropyValuesOS.version !== 'undefined')
-            result.version = parsedFromHighEntropyValuesOS.version;
-        if (result.name === OS.MacOS && typeof globalThis.navigator.standalone !== 'undefined' && globalThis.navigator.maxTouchPoints > 2)
-            result.name = OS.iOS;
+        if (typeof parsedFromHighEntropyValuesOSName !== 'undefined')
+            name = parsedFromHighEntropyValuesOSName;
+        if (typeof parsedFromHighEntropyValuesOSVersion !== 'undefined')
+            version = parsedFromHighEntropyValuesOSVersion;
+        if (name === OS.MacOS && typeof globalThis.navigator.standalone !== 'undefined' && globalThis.navigator.maxTouchPoints > 2)
+            name = OS.iOS;
     }
-    return result;
+    return { name: name, version: version };
 }
 function parseBrowser() {
-    var result = { name: Browsers.Unknown, version: '' };
+    var name = Browsers.Unknown;
+    var version = '';
     for (var i = 0; i < BROWSER_RESOLVER_MAP.length; i++) {
         var map = BROWSER_RESOLVER_MAP[i];
         var matched = currentUserAgent.match(map[0]);
         if (matched !== null) {
-            result.name = map[1];
-            result.version = resolveVersion(matched[1], map[2]);
+            name = map[1];
+            version = resolveVersion(matched[1], map[2]);
             break;
         }
     }
     if (currentUserAgent === USER_AGENT) {
-        if (typeof parsedFromHighEntropyValuesBrowser.name !== 'undefined')
-            result.name = parsedFromHighEntropyValuesBrowser.name;
-        if (typeof parsedFromHighEntropyValuesBrowser.version !== 'undefined')
-            result.version = parsedFromHighEntropyValuesBrowser.version;
+        if (typeof parsedFromHighEntropyValuesBrowserName !== 'undefined')
+            name = parsedFromHighEntropyValuesBrowserName;
+        if (typeof parsedFromHighEntropyValuesBrowserVersion !== 'undefined')
+            version = parsedFromHighEntropyValuesBrowserVersion;
     }
-    return result;
+    return { name: name, version: version };
 }
 function parseEngine() {
-    var result = { name: Engines.Unknown, version: '' };
+    var name = Engines.Unknown;
+    var version = '';
     for (var i = 0; i < ENGINE_RESOLVER_MAP.length; i++) {
         var map = ENGINE_RESOLVER_MAP[i];
         var matched = currentUserAgent.match(map[0]);
         if (matched !== null) {
-            result.name = map[1];
-            result.version = resolveVersion(matched[1], map[2]);
+            name = map[1];
+            version = resolveVersion(matched[1], map[2]);
             break;
         }
     }
     if (currentUserAgent === USER_AGENT) {
-        if (typeof parsedFromHighEntropyValuesEngine.name !== 'undefined')
-            result.name = parsedFromHighEntropyValuesEngine.name;
-        if (typeof parsedFromHighEntropyValuesEngine.version !== 'undefined')
-            result.version = parsedFromHighEntropyValuesEngine.version;
+        if (typeof parsedFromHighEntropyValuesEngineName !== 'undefined')
+            name = parsedFromHighEntropyValuesEngineName;
+        if (typeof parsedFromHighEntropyValuesEngineVersion !== 'undefined')
+            version = parsedFromHighEntropyValuesEngineVersion;
     }
-    return result;
+    return { name: name, version: version };
 }
 function getGPU() {
     return {
@@ -547,24 +556,22 @@ function getGPU() {
 function getLocale() {
     if (cachedLocale !== null)
         return cachedLocale;
-    var locale = {
-        language: null,
-        languages: [],
-        timezone: null,
-        offset: 0,
-        isRTL: false,
-    };
-    var isRTL = null;
-    function addLanguages(language) {
-        for (var i = 0; i < language.length; i++)
-            addLanguage(language[i]);
-    }
-    function addLanguage(language) {
-        language = normalizeLocale(language);
-        if (typeof language === 'string' && locale.languages.indexOf(language) === -1) {
-            if (locale.language === null)
-                locale.language = language;
-            locale.languages.push(language);
+    var language = null;
+    var languages = [];
+    var timezone = null;
+    var offset = 0;
+    var isRTL = false;
+    var isRTLResolved = null;
+    function addLanguages(langs) {
+        for (var i = 0; i < langs.length; i++)
+            addLanguage(langs[i]);
+    }
+    function addLanguage(lang) {
+        lang = normalizeLocale(lang);
+        if (typeof lang === 'string' && languages.indexOf(lang) === -1) {
+            if (language === null)
+                language = lang;
+            languages.push(lang);
         }
     }
     if (typeof Intl !== 'undefined') {
@@ -574,7 +581,7 @@ function getLocale() {
         catch (_) {
         }
         try {
-            locale.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         }
         catch (_) {
         }
@@ -592,38 +599,38 @@ function getLocale() {
             addLanguage(globalThis.navigator.systemLanguage);
     }
     try {
-        locale.offset = new Date().getTimezoneOffset() * -1;
+        offset = new Date().getTimezoneOffset() * -1;
     }
     catch (_) {
     }
-    if (typeof locale.language === 'string') {
+    if (typeof language === 'string') {
         if (typeof Intl !== 'undefined' && typeof Intl.Locale !== 'undefined') {
             try {
-                var intlLocale = new Intl.Locale(locale.language);
+                var intlLocale = new Intl.Locale(language);
                 if (typeof intlLocale.getTextInfo === 'function')
-                    isRTL = intlLocale.getTextInfo().direction === 'rtl';
+                    isRTLResolved = intlLocale.getTextInfo().direction === 'rtl';
                 else if (typeof intlLocale.textInfo !== 'undefined')
-                    isRTL = intlLocale.textInfo.direction === 'rtl';
+                    isRTLResolved = intlLocale.textInfo.direction === 'rtl';
             }
             catch (_) {
             }
         }
-        if (typeof isRTL !== 'boolean') {
-            var matched = /^([A-Za-z]{1,8})(?:[-_][A-Za-z0-9]{1,8})*$/.exec(locale.language);
+        if (typeof isRTLResolved !== 'boolean') {
+            var matched = /^([A-Za-z]{1,8})(?:[-_][A-Za-z0-9]{1,8})*$/.exec(language);
             if (matched !== null) {
-                var language = matched[1].toLowerCase();
+                var lang = matched[1].toLowerCase();
                 for (var i = 0; i < RTL_LANGUAGES.length; i++) {
-                    if (RTL_LANGUAGES[i] === language) {
-                        isRTL = true;
+                    if (RTL_LANGUAGES[i] === lang) {
+                        isRTLResolved = true;
                         break;
                     }
                 }
             }
         }
     }
-    if (typeof isRTL === 'boolean')
-        locale.isRTL = isRTL;
-    cachedLocale = locale;
+    if (typeof isRTLResolved === 'boolean')
+        isRTL = isRTLResolved;
+    cachedLocale = { language: language, languages: languages, timezone: timezone, offset: offset, isRTL: isRTL };
     return cachedLocale;
 }
 function getDevice() {
@@ -674,38 +681,38 @@ function parseFromHighEntropyValues() {
                     if (prevBrandName === null || /Chrom/.test(prevBrandName) || !/Chrom/.test(brandName)) {
                         browserName = brandName;
                         if (browserName === 'Chrome' || browserName === 'Chrome WebView' || browserName === 'Chrome Headless')
-                            parsedFromHighEntropyValuesBrowser.name = Browsers.Chrome;
+                            parsedFromHighEntropyValuesBrowserName = Browsers.Chrome;
                         else if (browserName === 'Edge' || browserName === 'Edge WebView2')
-                            parsedFromHighEntropyValuesBrowser.name = Browsers.Edge;
+                            parsedFromHighEntropyValuesBrowserName = Browsers.Edge;
                         else if (browserName === 'Opera Mobi')
-                            parsedFromHighEntropyValuesBrowser.name = Browsers.Opera;
-                        parsedFromHighEntropyValuesBrowser.version = brandVersion;
+                            parsedFromHighEntropyValuesBrowserName = Browsers.Opera;
+                        parsedFromHighEntropyValuesBrowserVersion = brandVersion;
                     }
                     prevBrandName = brandName;
                 }
                 if (brandName === 'Chromium')
-                    parsedFromHighEntropyValuesEngine.version = brandVersion;
+                    parsedFromHighEntropyValuesEngineVersion = brandVersion;
             }
             if (typeof platformVersion === 'string') {
                 if (getParsedCache().os.name === OS.Windows) {
                     if (parseInt(platformVersion.split('.')[0], 10) >= 13)
-                        parsedFromHighEntropyValuesOS.version = '11';
+                        parsedFromHighEntropyValuesOSVersion = '11';
                     else
-                        parsedFromHighEntropyValuesOS.version = '10';
+                        parsedFromHighEntropyValuesOSVersion = '10';
                 }
                 else {
-                    parsedFromHighEntropyValuesOS.version = platformVersion;
+                    parsedFromHighEntropyValuesOSVersion = platformVersion;
                 }
             }
             if (typeof platform === 'string') {
                 if (/android/i.test(platform))
-                    parsedFromHighEntropyValuesOS.name = OS.Android;
+                    parsedFromHighEntropyValuesOSName = OS.Android;
                 else if (/ios|iphone|ipad/i.test(platform))
-                    parsedFromHighEntropyValuesOS.name = OS.iOS;
+                    parsedFromHighEntropyValuesOSName = OS.iOS;
                 else if (/windows|win32/i.test(platform))
-                    parsedFromHighEntropyValuesOS.name = OS.Windows;
+                    parsedFromHighEntropyValuesOSName = OS.Windows;
                 else if (/macos|macintel/i.test(platform))
-                    parsedFromHighEntropyValuesOS.name = OS.MacOS;
+                    parsedFromHighEntropyValuesOSName = OS.MacOS;
             }
             if (result.mobile === true)
                 parsedFromHighEntropyValuesDevice = Devices.Mobile;
@@ -856,14 +863,14 @@ function createSubscriptionManager(attach, detach) {
     };
 }
 
-var onChangeSubscriptionManager$5 = createSubscriptionManager(attachOnChange$5, detachOnChange$5);
+var onChangeSubscriptionManager$4 = createSubscriptionManager(attachOnChange$4, detachOnChange$4);
 var appearanceRef = null;
 var pollingIntervalId = null;
 var Appearance = {
     get value() {
         return getAppearance();
     },
-    onChange: onChangeSubscriptionManager$5.subscribe,
+    onChange: onChangeSubscriptionManager$4.subscribe,
     Constants: {
         Appearances: Appearances
     },
@@ -899,7 +906,7 @@ function startPolling() {
         var appearance = getAppearanceFromEngine();
         if (appearance !== appearanceRef) {
             appearanceRef = appearance;
-            onChangeSubscriptionManager$5.emit(appearance);
+            onChangeSubscriptionManager$4.emit(appearance);
         }
     }, 2000);
 }
@@ -910,13 +917,13 @@ function stopPolling() {
         pollingIntervalId = null;
     }
 }
-function attachOnChange$5() {
+function attachOnChange$4() {
     appearanceRef = getAppearanceFromMediaQuery();
     EventListener.add(PREFERS_COLOR_SCHEME_MEDIA_QUERY_LIST, { type: 'change', callback: onMediaChange });
     if (Platform.browser.name === Browsers.SamsungInternet)
         startPolling();
 }
-function detachOnChange$5() {
+function detachOnChange$4() {
     appearanceRef = null;
     EventListener.remove(PREFERS_COLOR_SCHEME_MEDIA_QUERY_LIST, { type: 'change', callback: onMediaChange });
     if (Platform.browser.name === Browsers.SamsungInternet)
@@ -929,7 +936,7 @@ function onMediaChange(event) {
     else
         appearance = Appearances.Light;
     if (appearance !== appearanceRef)
-        onChangeSubscriptionManager$5.emit(appearanceRef = appearance);
+        onChangeSubscriptionManager$4.emit(appearanceRef = appearance);
 }
 
 function isSecureContext() {
@@ -1346,9 +1353,20 @@ function cleanupPaste(div, onPaste) {
 
 var Orientation;
 (function (Orientation) {
-    Orientation["Portrait"] = "portrait";
-    Orientation["Landscape"] = "landscape";
-    Orientation["Unknown"] = "unknown";
+    Orientation["PortraitPrimary"] = "portrait-primary";
+    Orientation["PortraitSecondary"] = "portrait-secondary";
+    Orientation["LandscapePrimary"] = "landscape-primary";
+    Orientation["LandscapeSecondary"] = "landscape-secondary";
+})(Orientation || (Orientation = {}));
+(function (Orientation) {
+    function isLandscape(orientation) {
+        return orientation === Orientation.LandscapePrimary || orientation === Orientation.LandscapeSecondary;
+    }
+    Orientation.isLandscape = isLandscape;
+    function isPortrait(orientation) {
+        return orientation === Orientation.PortraitPrimary || orientation === Orientation.PortraitSecondary;
+    }
+    Orientation.isPortrait = isPortrait;
 })(Orientation || (Orientation = {}));
 var ENV_PRESETS = {
     'safe-area-inset': {
@@ -1471,7 +1489,6 @@ function createViewportSegmentObserver() {
     var segmentMediaQueryLists = [];
     var previousSegments = null;
     function attachCSSFallbackListeners() {
-        EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
         segmentMediaQueryLists = buildSegmentMediaQueryLists();
         for (var i = 0; i < segmentMediaQueryLists.length; i++)
             EventListener.add(segmentMediaQueryLists[i], { type: 'change', callback: onSegmentChange });
@@ -1479,50 +1496,53 @@ function createViewportSegmentObserver() {
             EventListener.add(DEVICE_POSTURE_MEDIA_QUERY_LIST, { type: 'change', callback: onSegmentChange });
     }
     function detachCSSFallbackListeners() {
-        EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
         for (var i = 0; i < segmentMediaQueryLists.length; i++)
             EventListener.remove(segmentMediaQueryLists[i], { type: 'change', callback: onSegmentChange });
         segmentMediaQueryLists = [];
         if (DEVICE_POSTURE_MEDIA_QUERY_LIST.media !== 'not all')
             EventListener.remove(DEVICE_POSTURE_MEDIA_QUERY_LIST, { type: 'change', callback: onSegmentChange });
     }
+    function attachDevicePostureChangeListener() {
+        if (hasDevicePosture)
+            EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
+        attachCSSFallbackListeners();
+    }
+    function detachDevicePostureChangeListener() {
+        if (hasDevicePosture)
+            EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
+        detachCSSFallbackListeners();
+    }
+    function attachVisualViewportResizeListener() {
+        EventListener.add(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
+    }
+    function detachVisualViewportResizeListener() {
+        EventListener.remove(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
+    }
     function attachOnChange() {
+        EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
         if (hasSegmentsAPI) {
-            if (hasDevicePosture) {
-                EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
-                EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
-            }
-            else {
-                attachCSSFallbackListeners();
-            }
+            attachDevicePostureChangeListener();
         }
         else if (hasLegacySegmentsAPI) {
-            EventListener.add(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
-            if (hasSegmentsAPI)
-                EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
+            attachVisualViewportResizeListener();
+            attachDevicePostureChangeListener();
         }
         else {
             getOrCreateCachedDiv();
-            attachCSSFallbackListeners();
+            attachVisualViewportResizeListener();
         }
     }
     function detachOnChange() {
+        EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
         if (hasSegmentsAPI) {
-            if (hasDevicePosture) {
-                EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
-                EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
-            }
-            else {
-                detachCSSFallbackListeners();
-            }
+            detachDevicePostureChangeListener();
         }
         else if (hasLegacySegmentsAPI) {
-            EventListener.remove(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
-            if (hasSegmentsAPI)
-                EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
+            detachVisualViewportResizeListener();
+            detachDevicePostureChangeListener();
         }
         else {
-            detachCSSFallbackListeners();
+            detachVisualViewportResizeListener();
             releaseDiv();
         }
     }
@@ -1674,7 +1694,7 @@ function createViewportSegmentObserver() {
         function applySegments(segments) {
             for (var i = segments.length; i < lastCount; i++) {
                 for (var j = 0; j < attributes.length; j++) {
-                    element.style.removeProperty("--".concat(prefix, "-").concat(i, "-").concat(attributes[j]));
+                    element.style.removeProperty('--' + prefix + '-' + i + '-' + attributes[j]);
                 }
             }
             lastCount = segments.length;
@@ -1682,7 +1702,7 @@ function createViewportSegmentObserver() {
                 var segment = segments[i];
                 for (var j = 0; j < attributes.length; j++) {
                     var attribute = attributes[j];
-                    element.style.setProperty("--".concat(prefix, "-").concat(i, "-").concat(attribute), segment[attribute] + 'px');
+                    element.style.setProperty('--' + prefix + '-' + i + '-' + attribute, segment[attribute] + 'px');
                 }
             }
         }
@@ -1694,7 +1714,7 @@ function createViewportSegmentObserver() {
             unsubscribe();
             for (var i = 0; i < lastCount; i++)
                 for (var j = 0; j < attributes.length; j++)
-                    element.style.removeProperty("--".concat(prefix, "-").concat(i, "-").concat(attributes[j]));
+                    element.style.removeProperty('--' + prefix + '-' + i + '-' + attributes[j]);
             lastCount = 0;
         };
     }
@@ -1708,15 +1728,11 @@ function createViewportSegmentObserver() {
 }
 function createVirtualKeyboardObserver() {
     var onChangeSubscriptionManager = createSubscriptionManager(attachOnChange, detachOnChange);
-    var previousOverlaysContent = false;
     function attachOnChange() {
-        previousOverlaysContent = globalThis.navigator.virtualKeyboard.overlaysContent;
-        globalThis.navigator.virtualKeyboard.overlaysContent = true;
         EventListener.add(globalThis.navigator.virtualKeyboard, { type: 'geometrychange', callback: onGeometryChange, options: { passive: true } });
     }
     function detachOnChange() {
         EventListener.remove(globalThis.navigator.virtualKeyboard, { type: 'geometrychange', callback: onGeometryChange, options: { passive: true } });
-        globalThis.navigator.virtualKeyboard.overlaysContent = previousOverlaysContent;
     }
     function onGeometryChange() {
         onChangeSubscriptionManager.emit(getValue());
@@ -1754,7 +1770,7 @@ function createVirtualKeyboardObserver() {
         function applyValues(values) {
             for (var i = 0; i < attributes.length; i++) {
                 var attribute = attributes[i];
-                element.style.setProperty("--".concat(prefix, "-").concat(attribute), values[attribute] + 'px');
+                element.style.setProperty('--' + prefix + '-' + attribute, values[attribute] + 'px');
             }
         }
         applyValues(getValue());
@@ -1764,7 +1780,7 @@ function createVirtualKeyboardObserver() {
         return function () {
             unsubscribe();
             for (var i = 0; i < attributes.length; i++)
-                element.style.removeProperty("--".concat(prefix, "-").concat(attributes[i]));
+                element.style.removeProperty('--' + prefix + '-' + attributes[i]);
         };
     }
     return {
@@ -1953,7 +1969,7 @@ function createEnvironmentObserver(preset) {
         function applyValues(values) {
             for (var i = 0; i < attributes.length; i++) {
                 var attribute = attributes[i];
-                element.style.setProperty("--".concat(prefix, "-").concat(String(attribute)), values[attribute] + 'px');
+                element.style.setProperty('--' + prefix + '-' + String(attributes[i]), values[attribute] + 'px');
             }
         }
         var unsubscribe = onChangeSubscriptionManager.subscribe(function (values) {
@@ -1963,7 +1979,7 @@ function createEnvironmentObserver(preset) {
         return function () {
             unsubscribe();
             for (var i = 0; i < attributes.length; i++)
-                element.style.removeProperty("--".concat(prefix, "-").concat(String(attributes[i])));
+                element.style.removeProperty('--' + prefix + '-' + String(attributes[i]));
         };
     }
     return {
@@ -1985,109 +2001,6 @@ function createEnvironmentObserver(preset) {
     };
 }
 
-var safeAreaInsetObserver = createEnvironmentObserver('safe-area-inset');
-var safeAreaMaxInsetObserver = createEnvironmentObserver('safe-area-max-inset');
-var keyboardInsetObserver = createEnvironmentObserver('keyboard-inset');
-var titlebarAreaObserver = createEnvironmentObserver('titlebar-area');
-var viewportSegmentObserver = createEnvironmentObserver('viewport-segment');
-var onChangeSubscriptionManager$4 = createSubscriptionManager(attachOnChange$4, detachOnChange$4);
-var dimensionRef = null;
-var Dimension = {
-    get value() {
-        return getDimension();
-    },
-    environment: getEnvironment(),
-    onChange: onChangeSubscriptionManager$4.subscribe,
-    Constants: {
-        Orientation: Orientation,
-    },
-    Errors: {},
-};
-function getOrientation() {
-    if (typeof globalThis.screen !== 'undefined') {
-        switch (globalThis.screen.orientation.type) {
-            case 'portrait-primary':
-            case 'portrait-secondary':
-                return Orientation.Portrait;
-            case 'landscape-primary':
-            case 'landscape-secondary':
-                return Orientation.Landscape;
-        }
-    }
-    if (typeof globalThis.orientation !== 'undefined') {
-        switch (globalThis.orientation) {
-            case 0:
-            case 180:
-                return Orientation.Portrait;
-            case 90:
-            case 270:
-                return Orientation.Landscape;
-        }
-    }
-    if (ORIENTATION_MEDIA_QUERY_LIST.media === 'not all')
-        return Orientation.Unknown;
-    else if (ORIENTATION_MEDIA_QUERY_LIST.matches)
-        return Orientation.Portrait;
-    else
-        return Orientation.Landscape;
-}
-function getScale() {
-    if (typeof globalThis.devicePixelRatio !== 'undefined')
-        return globalThis.devicePixelRatio;
-    return -1;
-}
-function getEnvironment() {
-    return {
-        safeAreaInset: safeAreaInsetObserver,
-        safeAreaMaxInset: safeAreaMaxInsetObserver,
-        keyboardInset: keyboardInsetObserver,
-        titlebarArea: titlebarAreaObserver,
-        viewportSegment: viewportSegmentObserver,
-    };
-}
-function getDimension() {
-    var dimensions = {
-        innerWidth: 0,
-        innerHeight: 0,
-        outerWidth: 0,
-        outerHeight: 0,
-        scale: getScale(),
-        orientation: getOrientation(),
-    };
-    if (typeof globalThis.innerWidth !== 'undefined') {
-        dimensions.innerWidth = globalThis.innerWidth;
-        dimensions.innerHeight = globalThis.innerHeight;
-        dimensions.outerWidth = globalThis.outerWidth;
-        dimensions.outerHeight = globalThis.outerHeight;
-    }
-    return dimensions;
-}
-function attachOnChange$4() {
-    dimensionRef = getDimension();
-    EventListener.add(globalThis, { type: 'resize', callback: onResize });
-    if (typeof globalThis.screen.orientation.addEventListener === 'function')
-        EventListener.add(globalThis.screen.orientation, { type: 'change', callback: onResize });
-    else if (typeof globalThis.orientation !== 'undefined')
-        EventListener.add(globalThis, { type: 'orientationChange', callback: onResize });
-    else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
-        EventListener.add(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onResize });
-}
-function detachOnChange$4() {
-    dimensionRef = null;
-    EventListener.remove(globalThis, { type: 'resize', callback: onResize });
-    if (typeof globalThis.screen.orientation.removeEventListener === 'function')
-        EventListener.remove(globalThis.screen.orientation, { type: 'change', callback: onResize });
-    else if (typeof globalThis.orientation !== 'undefined')
-        EventListener.remove(globalThis, { type: 'orientationChange', callback: onResize });
-    else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
-        EventListener.remove(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onResize });
-}
-function onResize() {
-    var dimension = getDimension();
-    if (dimensionRef === null || dimension.innerWidth !== dimensionRef.innerWidth || dimension.innerHeight !== dimensionRef.innerHeight || dimension.outerWidth !== dimensionRef.outerWidth || dimension.outerHeight !== dimensionRef.outerHeight || dimension.scale !== dimensionRef.scale || dimension.orientation !== dimensionRef.orientation)
-        onChangeSubscriptionManager$4.emit(dimensionRef = dimension);
-}
-
 function createCustomError(name, Base) {
     if (Base === void 0) { Base = Error; }
     function CustomError(message) {
@@ -2170,8 +2083,248 @@ function createCustomError(name, Base) {
     return CustomError;
 }
 
+var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
+
 var NotSupportedError = createCustomError('NotSupportedError');
 
+var safeAreaInsetObserver = createEnvironmentObserver('safe-area-inset');
+var safeAreaMaxInsetObserver = createEnvironmentObserver('safe-area-max-inset');
+var keyboardInsetObserver = createEnvironmentObserver('keyboard-inset');
+var titlebarAreaObserver = createEnvironmentObserver('titlebar-area');
+var viewportSegmentObserver = createEnvironmentObserver('viewport-segment');
+var onDimensionChangeSubscriptionManager = createSubscriptionManager(attachOnDimensionChange, detachOnDimensionChange);
+var onScreenOrientationChangeSubscriptionManager = createSubscriptionManager(attachOnScreenOrientationChange, detachOnScreenOrientationChange);
+var onDeviceOrientationChangeSubscriptionManager = createSubscriptionManager(attachOnDeviceOrientationChange, detachOnDeviceOrientationChange);
+var dimensionRef = null;
+var screenOrientationRef = null;
+var deviceOrientationRef = null;
+var Dimension = {
+    get value() {
+        return getDimension();
+    },
+    environment: getEnvironment(),
+    screenOrientation: getScreenOrientation(),
+    deviceOrientation: getDeviceOrientation(),
+    onChange: onDimensionChangeSubscriptionManager.subscribe,
+    Constants: {
+        Orientation: Orientation,
+    },
+    Errors: {
+        NotSupportedError: NotSupportedError,
+        PermissionNotGrantedError: PermissionNotGrantedError,
+    },
+};
+function getOrientation() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.type !== 'undefined') {
+        switch (globalThis.screen.orientation.type) {
+            case 'portrait-primary':
+                return Orientation.PortraitPrimary;
+            case 'portrait-secondary':
+                return Orientation.PortraitSecondary;
+            case 'landscape-primary':
+                return Orientation.LandscapePrimary;
+            case 'landscape-secondary':
+                return Orientation.LandscapeSecondary;
+        }
+    }
+    if (typeof globalThis.orientation !== 'undefined') {
+        switch (globalThis.orientation) {
+            case 0:
+                return Orientation.PortraitPrimary;
+            case 180:
+                return Orientation.PortraitSecondary;
+            case 90:
+                return Orientation.LandscapePrimary;
+            case -90:
+            case 270:
+                return Orientation.LandscapeSecondary;
+        }
+    }
+    if (ORIENTATION_MEDIA_QUERY_LIST.media === 'not all')
+        throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
+    if (ORIENTATION_MEDIA_QUERY_LIST.matches)
+        return Orientation.PortraitPrimary;
+    else
+        return Orientation.LandscapePrimary;
+}
+function getScale() {
+    if (typeof globalThis.devicePixelRatio !== 'undefined')
+        return globalThis.devicePixelRatio;
+    return -1;
+}
+function getEnvironment() {
+    return {
+        safeAreaInset: safeAreaInsetObserver,
+        safeAreaMaxInset: safeAreaMaxInsetObserver,
+        keyboardInset: keyboardInsetObserver,
+        titlebarArea: titlebarAreaObserver,
+        viewportSegment: viewportSegmentObserver,
+    };
+}
+function getScreenOrientation() {
+    return {
+        get supported() {
+            return screenOrientationSupported();
+        },
+        get value() {
+            return getOrientation();
+        },
+        onChange: onScreenOrientationChangeSubscriptionManager.subscribe,
+    };
+}
+function getDeviceOrientation() {
+    return {
+        get supported() {
+            return deviceOrientationSupported();
+        },
+        get value() {
+            return getDeviceOrientationValue();
+        },
+        onChange: onDeviceOrientationChangeSubscriptionManager.subscribe,
+    };
+}
+function getDimension() {
+    var innerWidth = 0;
+    var innerHeight = 0;
+    var outerWidth = 0;
+    var outerHeight = 0;
+    var scale = getScale();
+    if (typeof globalThis.innerWidth !== 'undefined') {
+        innerWidth = globalThis.innerWidth;
+        innerHeight = globalThis.innerHeight;
+        outerWidth = globalThis.outerWidth;
+        outerHeight = globalThis.outerHeight;
+    }
+    return {
+        innerWidth: innerWidth,
+        innerHeight: innerHeight,
+        outerWidth: outerWidth,
+        outerHeight: outerHeight,
+        scale: scale,
+    };
+}
+function attachOnDimensionChange() {
+    dimensionRef = getDimension();
+    EventListener.add(globalThis, { type: 'resize', callback: onDimensionChange });
+}
+function detachOnDimensionChange() {
+    dimensionRef = null;
+    EventListener.remove(globalThis, { type: 'resize', callback: onDimensionChange });
+}
+function onDimensionChange() {
+    var dimension = getDimension();
+    if (dimensionRef === null || dimension.innerWidth !== dimensionRef.innerWidth || dimension.innerHeight !== dimensionRef.innerHeight || dimension.outerWidth !== dimensionRef.outerWidth || dimension.outerHeight !== dimensionRef.outerHeight || dimension.scale !== dimensionRef.scale)
+        onDimensionChangeSubscriptionManager.emit(dimensionRef = dimension);
+}
+function screenOrientationSupported() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.type !== 'undefined')
+        return true;
+    if (typeof globalThis.orientation !== 'undefined')
+        return true;
+    return ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all';
+}
+function attachOnScreenOrientationChange() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.addEventListener === 'function')
+        EventListener.add(globalThis.screen.orientation, {
+            type: 'change',
+            callback: onScreenOrientationChange
+        });
+    else if (typeof globalThis.orientation !== 'undefined')
+        EventListener.add(globalThis, { type: 'orientationchange', callback: onScreenOrientationChange });
+    else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
+        EventListener.add(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onScreenOrientationChange });
+    throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
+}
+function detachOnScreenOrientationChange() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.removeEventListener === 'function')
+        EventListener.remove(globalThis.screen.orientation, {
+            type: 'change',
+            callback: onScreenOrientationChange
+        });
+    else if (typeof globalThis.orientation !== 'undefined')
+        EventListener.remove(globalThis, { type: 'orientationchange', callback: onScreenOrientationChange });
+    else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
+        EventListener.remove(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onScreenOrientationChange });
+    throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
+}
+function onScreenOrientationChange() {
+    var orientation = getOrientation();
+    if (screenOrientationRef === null || orientation !== screenOrientationRef)
+        onScreenOrientationChangeSubscriptionManager.emit(screenOrientationRef = orientation);
+}
+function deviceOrientationSupported() {
+    return typeof globalThis.DeviceOrientationEvent !== 'undefined';
+}
+function attachOnDeviceOrientationChange() {
+    return new Promise(function (resolve, reject) {
+        if (!deviceOrientationSupported())
+            return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+        var DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+        if (typeof DeviceOrientationEventWithPermission.requestPermission === 'function') {
+            DeviceOrientationEventWithPermission.requestPermission().then(function (permission) {
+                if (permission === 'granted') {
+                    EventListener.add(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+                    return resolve();
+                }
+                return reject(new PermissionNotGrantedError('\'deviceorientation\' permission is not granted.'));
+            }).catch(function (_) {
+                return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+            });
+        }
+        else {
+            EventListener.add(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+            return resolve();
+        }
+    });
+}
+function detachOnDeviceOrientationChange() {
+    EventListener.remove(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+}
+function onDeviceOrientationChange(event) {
+    deviceOrientationRef = {
+        alpha: event.alpha,
+        beta: event.beta,
+        gamma: event.gamma,
+        absolute: event.absolute,
+    };
+    onDeviceOrientationChangeSubscriptionManager.emit(deviceOrientationRef);
+}
+function getDeviceOrientationValue() {
+    return new Promise(function (resolve, reject) {
+        if (deviceOrientationRef !== null)
+            return resolve(deviceOrientationRef);
+        if (!deviceOrientationSupported())
+            return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+        var DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+        var callback = function (event) {
+            var value = {
+                alpha: event.alpha,
+                beta: event.beta,
+                gamma: event.gamma,
+                absolute: event.absolute,
+            };
+            deviceOrientationRef = value;
+            EventListener.remove(globalThis, { type: 'deviceorientation', callback: callback });
+            return resolve(value);
+        };
+        if (typeof DeviceOrientationEventWithPermission.requestPermission === 'function') {
+            DeviceOrientationEventWithPermission.requestPermission().then(function (permission) {
+                if (permission === 'granted') {
+                    EventListener.add(globalThis, { type: 'deviceorientation', callback: callback });
+                    return;
+                }
+                return reject(new PermissionNotGrantedError('\'deviceorientation\' permission is not granted.'));
+            }).catch(function (_) {
+                return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+            });
+        }
+        else {
+            EventListener.add(globalThis, { type: 'deviceorientation', callback: callback });
+            return;
+        }
+    });
+}
+
 var InvalidStateError = createCustomError('InvalidStateError');
 
 var videoElement$1 = null;
@@ -2576,6 +2729,8 @@ var PermissionType;
     PermissionType["ClipboardRead"] = "clipboard-read";
     PermissionType["Microphone"] = "microphone";
     PermissionType["MIDI"] = "midi";
+    PermissionType["DeviceOrientation"] = "device-orientation";
+    PermissionType["DeviceMotion"] = "device-motion";
 })(PermissionType || (PermissionType = {}));
 var PermissionState;
 (function (PermissionState) {
@@ -2617,14 +2772,45 @@ var Permission = {
         PermissionType: PermissionType,
         PermissionState: PermissionState,
     },
-    Errors: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+    },
 };
+function toPermissionState(permission) {
+    switch (permission) {
+        case 'granted':
+            return PermissionState.Grant;
+        case 'denied':
+            return PermissionState.Denied;
+        case 'prompt':
+        case 'default':
+            return PermissionState.Prompt;
+        default:
+            return PermissionState.Unsupported;
+    }
+}
+function toSafariSensorEventMap(type) {
+    switch (type) {
+        case PermissionType.DeviceOrientation:
+            return {
+                event: globalThis.DeviceOrientationEvent,
+                type: 'deviceorientation',
+            };
+        case PermissionType.DeviceMotion:
+            return {
+                event: globalThis.DeviceMotionEvent,
+                type: 'devicemotion',
+            };
+        default:
+            return undefined;
+    }
+}
 function supported$5() {
     return typeof globalThis.navigator.permissions !== 'undefined';
 }
 function request$2(type) {
     var instance = this;
-    return new Promise(function (resolve) {
+    return new Promise(function (resolve, reject) {
         function resolveAfterCheck() {
             instance.check(type).then(resolve);
         }
@@ -2636,17 +2822,8 @@ function request$2(type) {
                 case PermissionType.Notification:
                     if (typeof globalThis.Notification === 'undefined')
                         return resolve(PermissionState.Unsupported);
-                    globalThis.Notification.requestPermission().then(function (value) {
-                        switch (value) {
-                            case 'default':
-                                return resolve(PermissionState.Prompt);
-                            case 'granted':
-                                return resolve(PermissionState.Grant);
-                            case 'denied':
-                                return resolve(PermissionState.Denied);
-                            default:
-                                resolveAfterCheck();
-                        }
+                    globalThis.Notification.requestPermission().then(function (permission) {
+                        resolve(toPermissionState(permission));
                     });
                     break;
                 case PermissionType.Geolocation:
@@ -2684,6 +2861,23 @@ function request$2(type) {
                         .then(resolveAfterCheck)
                         .catch(resolveAfterCheck);
                     break;
+                case PermissionType.DeviceOrientation:
+                case PermissionType.DeviceMotion:
+                    var sensorEventMap = toSafariSensorEventMap(type);
+                    if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    if (typeof sensorEventMap.event.requestPermission !== 'function')
+                        return resolve(PermissionState.Grant);
+                    try {
+                        sensorEventMap.event.requestPermission()
+                            .then(function (permission) {
+                            resolve(toPermissionState(permission));
+                        });
+                    }
+                    catch (_) {
+                        return reject(new NotSupportedError('\'DeviceOrientationEvent.requestPermission()\' must be called within a user gesture context.'));
+                    }
+                    break;
                 default:
                     return resolve(PermissionState.Unsupported);
             }
@@ -2691,6 +2885,34 @@ function request$2(type) {
     });
 }
 function check(type) {
+    if (type === PermissionType.DeviceOrientation || type === PermissionType.DeviceMotion) {
+        return new Promise(function (resolve) {
+            var sensorEventMap = toSafariSensorEventMap(type);
+            if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                return resolve(PermissionState.Unsupported);
+            if (typeof sensorEventMap.event.requestPermission !== 'function')
+                return resolve(PermissionState.Grant);
+            var granted = false;
+            EventListener.add(globalThis, {
+                type: sensorEventMap.type,
+                callback: function () {
+                    granted = true;
+                },
+                options: { once: true }
+            });
+            setTimeout(function () {
+                if (granted)
+                    return resolve(PermissionState.Grant);
+                sensorEventMap.event.requestPermission()
+                    .then(function (permission) {
+                    resolve(toPermissionState(permission));
+                })
+                    .catch(function () {
+                    resolve(PermissionState.Prompt);
+                });
+            }, 50);
+        });
+    }
     return new Promise(function (resolve) {
         if (typeof globalThis.navigator.permissions === 'undefined')
             return resolve(PermissionState.Unsupported);
@@ -2710,8 +2932,6 @@ function check(type) {
     });
 }
 
-var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
-
 function request$1(url, options) {
     return new Promise(function (resolve) {
         var method = 'GET';