native-fn 1.3.0 → 1.3.1

package/dist/native.umd.js

@@ -4,7 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Native = factory());
 })(this, (function () { 'use strict';
 
-  var version = "1.3.0";
+  var version = "1.3.1";
   var packageJSON = {
   	version: version};
 
@@ -409,9 +409,12 @@
 
   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;
@@ -458,9 +461,12 @@
   function invalidateCache() {
       parsedCache = null;
       cachedLocale = null;
-      parsedFromHighEntropyValuesOS = {};
-      parsedFromHighEntropyValuesBrowser = {};
-      parsedFromHighEntropyValuesEngine = {};
+      parsedFromHighEntropyValuesOSName = undefined;
+      parsedFromHighEntropyValuesOSVersion = undefined;
+      parsedFromHighEntropyValuesBrowserName = undefined;
+      parsedFromHighEntropyValuesBrowserVersion = undefined;
+      parsedFromHighEntropyValuesEngineName = undefined;
+      parsedFromHighEntropyValuesEngineVersion = undefined;
       parsedFromHighEntropyValuesDevice = null;
       parsedFromNavigatorGPU = {};
   }
@@ -476,71 +482,74 @@
       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 {
@@ -553,24 +562,22 @@
   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') {
@@ -580,7 +587,7 @@
           catch (_) {
           }
           try {
-              locale.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+              timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
           }
           catch (_) {
           }
@@ -598,38 +605,38 @@
               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() {
@@ -680,38 +687,38 @@
                       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;
@@ -862,14 +869,14 @@
       };
   }
 
-  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
       },
@@ -905,7 +912,7 @@
           var appearance = getAppearanceFromEngine();
           if (appearance !== appearanceRef) {
               appearanceRef = appearance;
-              onChangeSubscriptionManager$5.emit(appearance);
+              onChangeSubscriptionManager$4.emit(appearance);
           }
       }, 2000);
   }
@@ -916,13 +923,13 @@
           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)
@@ -935,7 +942,7 @@
       else
           appearance = Appearances.Light;
       if (appearance !== appearanceRef)
-          onChangeSubscriptionManager$5.emit(appearanceRef = appearance);
+          onChangeSubscriptionManager$4.emit(appearanceRef = appearance);
   }
 
   function isSecureContext() {
@@ -1352,9 +1359,20 @@
 
   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': {
@@ -1477,7 +1495,6 @@
       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 });
@@ -1485,50 +1502,53 @@
               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();
           }
       }
@@ -1680,7 +1700,7 @@
           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;
@@ -1688,7 +1708,7 @@
                   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');
                   }
               }
           }
@@ -1700,7 +1720,7 @@
               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;
           };
       }
@@ -1714,15 +1734,11 @@
   }
   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());
@@ -1760,7 +1776,7 @@
           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());
@@ -1770,7 +1786,7 @@
           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 {
@@ -1959,7 +1975,7 @@
           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) {
@@ -1969,7 +1985,7 @@
           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 {
@@ -1991,109 +2007,6 @@
       };
   }
 
-  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) {
@@ -2176,8 +2089,248 @@
       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;
@@ -2582,6 +2735,8 @@
       PermissionType["ClipboardRead"] = "clipboard-read";
       PermissionType["Microphone"] = "microphone";
       PermissionType["MIDI"] = "midi";
+      PermissionType["DeviceOrientation"] = "device-orientation";
+      PermissionType["DeviceMotion"] = "device-motion";
   })(PermissionType || (PermissionType = {}));
   var PermissionState;
   (function (PermissionState) {
@@ -2623,14 +2778,45 @@
           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);
           }
@@ -2642,17 +2828,8 @@
                   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:
@@ -2690,6 +2867,23 @@
                           .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);
               }
@@ -2697,6 +2891,34 @@
       });
   }
   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);
@@ -2716,8 +2938,6 @@
       });
   }
 
-  var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
-
   function request$1(url, options) {
       return new Promise(function (resolve) {
           var method = 'GET';