@arcgis/map-components 4.29.0-beta.7 → 4.29.0-beta.72

package/dist/cjs/index-09a0e90f.js

@@ -0,0 +1,735 @@
+'use strict';
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () {
+                        return e[k];
+                    }
+                });
+            }
+        });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+}
+
+const amd = "define" in window && typeof window.define === "function" && "amd" in window.define;
+function requireModule(modulePath) {
+    return new Promise((resolve) => window.require([modulePath], (moduleDefault) => {
+        resolve(moduleDefault);
+    }));
+}
+async function importLayersFeatureLayer() {
+    if (amd) {
+        return requireModule("esri/layers/FeatureLayer");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/layers/FeatureLayer.js')); });
+    return module.default;
+}
+async function newLayersFeatureLayer(properties) {
+    const ModConstructor = await importLayersFeatureLayer();
+    return new ModConstructor(properties);
+}
+async function importLayersGraphicsLayer() {
+    if (amd) {
+        return requireModule("esri/layers/GraphicsLayer");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/layers/GraphicsLayer.js')); });
+    return module.default;
+}
+async function newLayersGraphicsLayer(properties) {
+    const ModConstructor = await importLayersGraphicsLayer();
+    return new ModConstructor(properties);
+}
+async function importLayersRouteLayer() {
+    if (amd) {
+        return requireModule("esri/layers/RouteLayer");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/layers/RouteLayer.js')); });
+    return module.default;
+}
+async function newLayersRouteLayer(properties) {
+    const ModConstructor = await importLayersRouteLayer();
+    return new ModConstructor(properties);
+}
+async function importViewsMapView() {
+    if (amd) {
+        return requireModule("esri/views/MapView");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/views/MapView.js')); });
+    return module.default;
+}
+async function newViewsMapView(properties) {
+    const ModConstructor = await importViewsMapView();
+    return new ModConstructor(properties);
+}
+async function importViewsSceneView() {
+    if (amd) {
+        return requireModule("esri/views/SceneView");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/views/SceneView.js')); });
+    return module.default;
+}
+async function newViewsSceneView(properties) {
+    const ModConstructor = await importViewsSceneView();
+    return new ModConstructor(properties);
+}
+async function importWebMap() {
+    if (amd) {
+        return requireModule("esri/WebMap");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebMap.js')); });
+    return module.default;
+}
+async function newWebMap(properties) {
+    const ModConstructor = await importWebMap();
+    return new ModConstructor(properties);
+}
+async function importWebScene() {
+    if (amd) {
+        return requireModule("esri/WebScene");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebScene.js')); });
+    return module.default;
+}
+async function newWebScene(properties) {
+    const ModConstructor = await importWebScene();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAreaMeasurement2D() {
+    if (amd) {
+        return requireModule("esri/widgets/AreaMeasurement2D");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/AreaMeasurement2D.js')); });
+    return module.default;
+}
+async function newWidgetsAreaMeasurement2D(properties) {
+    const ModConstructor = await importWidgetsAreaMeasurement2D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAreaMeasurement3D() {
+    if (amd) {
+        return requireModule("esri/widgets/AreaMeasurement3D");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/AreaMeasurement3D.js')); });
+    return module.default;
+}
+async function newWidgetsAreaMeasurement3D(properties) {
+    const ModConstructor = await importWidgetsAreaMeasurement3D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsAttachments() {
+    if (amd) {
+        return requireModule("esri/widgets/Attachments");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Attachments.js')); });
+    return module.default;
+}
+async function newWidgetsAttachments(properties) {
+    const ModConstructor = await importWidgetsAttachments();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapGallery() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapGallery");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/BasemapGallery.js')); });
+    return module.default;
+}
+async function newWidgetsBasemapGallery(properties) {
+    const ModConstructor = await importWidgetsBasemapGallery();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapLayerList() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapLayerList");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/BasemapLayerList.js')); });
+    return module.default;
+}
+async function newWidgetsBasemapLayerList(properties) {
+    const ModConstructor = await importWidgetsBasemapLayerList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBasemapToggle() {
+    if (amd) {
+        return requireModule("esri/widgets/BasemapToggle");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/BasemapToggle.js')); });
+    return module.default;
+}
+async function newWidgetsBasemapToggle(properties) {
+    const ModConstructor = await importWidgetsBasemapToggle();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBookmarks() {
+    if (amd) {
+        return requireModule("esri/widgets/Bookmarks");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Bookmarks.js')); });
+    return module.default;
+}
+async function newWidgetsBookmarks(properties) {
+    const ModConstructor = await importWidgetsBookmarks();
+    return new ModConstructor(properties);
+}
+async function importWidgetsBuildingExplorer() {
+    if (amd) {
+        return requireModule("esri/widgets/BuildingExplorer");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/BuildingExplorer.js')); });
+    return module.default;
+}
+async function newWidgetsBuildingExplorer(properties) {
+    const ModConstructor = await importWidgetsBuildingExplorer();
+    return new ModConstructor(properties);
+}
+async function importWidgetsCompass() {
+    if (amd) {
+        return requireModule("esri/widgets/Compass");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Compass.js')); });
+    return module.default;
+}
+async function newWidgetsCompass(properties) {
+    const ModConstructor = await importWidgetsCompass();
+    return new ModConstructor(properties);
+}
+async function importWidgetsCoordinateConversion() {
+    if (amd) {
+        return requireModule("esri/widgets/CoordinateConversion");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/CoordinateConversion.js')); });
+    return module.default;
+}
+async function newWidgetsCoordinateConversion(properties) {
+    const ModConstructor = await importWidgetsCoordinateConversion();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDaylight() {
+    if (amd) {
+        return requireModule("esri/widgets/Daylight");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Daylight.js')); });
+    return module.default;
+}
+async function newWidgetsDaylight(properties) {
+    const ModConstructor = await importWidgetsDaylight();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDirections() {
+    if (amd) {
+        return requireModule("esri/widgets/Directions");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Directions.js')); });
+    return module.default;
+}
+async function newWidgetsDirections(properties) {
+    const ModConstructor = await importWidgetsDirections();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDirectLineMeasurement3D() {
+    if (amd) {
+        return requireModule("esri/widgets/DirectLineMeasurement3D");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/DirectLineMeasurement3D.js')); });
+    return module.default;
+}
+async function newWidgetsDirectLineMeasurement3D(properties) {
+    const ModConstructor = await importWidgetsDirectLineMeasurement3D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsDistanceMeasurement2D() {
+    if (amd) {
+        return requireModule("esri/widgets/DistanceMeasurement2D");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/DistanceMeasurement2D.js')); });
+    return module.default;
+}
+async function newWidgetsDistanceMeasurement2D(properties) {
+    const ModConstructor = await importWidgetsDistanceMeasurement2D();
+    return new ModConstructor(properties);
+}
+async function importWidgetsEditor() {
+    if (amd) {
+        return requireModule("esri/widgets/Editor");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Editor.js')); });
+    return module.default;
+}
+async function newWidgetsEditor(properties) {
+    const ModConstructor = await importWidgetsEditor();
+    return new ModConstructor(properties);
+}
+async function importWidgetsElevationProfile() {
+    if (amd) {
+        return requireModule("esri/widgets/ElevationProfile");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/ElevationProfile.js')); });
+    return module.default;
+}
+async function newWidgetsElevationProfile(properties) {
+    const ModConstructor = await importWidgetsElevationProfile();
+    return new ModConstructor(properties);
+}
+async function importWidgetsExpand() {
+    if (amd) {
+        return requireModule("esri/widgets/Expand");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Expand.js')); });
+    return module.default;
+}
+async function newWidgetsExpand(properties) {
+    const ModConstructor = await importWidgetsExpand();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeature() {
+    if (amd) {
+        return requireModule("esri/widgets/Feature");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Feature.js')); });
+    return module.default;
+}
+async function newWidgetsFeature(properties) {
+    const ModConstructor = await importWidgetsFeature();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureForm() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureForm");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/FeatureForm.js')); });
+    return module.default;
+}
+async function newWidgetsFeatureForm(properties) {
+    const ModConstructor = await importWidgetsFeatureForm();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatures() {
+    if (amd) {
+        return requireModule("esri/widgets/Features");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Features.js')); });
+    return module.default;
+}
+async function newWidgetsFeatures(properties) {
+    const ModConstructor = await importWidgetsFeatures();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureTable() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureTable");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/FeatureTable.js')); });
+    return module.default;
+}
+async function newWidgetsFeatureTable(properties) {
+    const ModConstructor = await importWidgetsFeatureTable();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFeatureTemplates() {
+    if (amd) {
+        return requireModule("esri/widgets/FeatureTemplates");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/FeatureTemplates.js')); });
+    return module.default;
+}
+async function newWidgetsFeatureTemplates(properties) {
+    const ModConstructor = await importWidgetsFeatureTemplates();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFloorFilter() {
+    if (amd) {
+        return requireModule("esri/widgets/FloorFilter");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/FloorFilter.js')); });
+    return module.default;
+}
+async function newWidgetsFloorFilter(properties) {
+    const ModConstructor = await importWidgetsFloorFilter();
+    return new ModConstructor(properties);
+}
+async function importWidgetsFullscreen() {
+    if (amd) {
+        return requireModule("esri/widgets/Fullscreen");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Fullscreen.js')); });
+    return module.default;
+}
+async function newWidgetsFullscreen(properties) {
+    const ModConstructor = await importWidgetsFullscreen();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHistogram() {
+    if (amd) {
+        return requireModule("esri/widgets/Histogram");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Histogram.js')); });
+    return module.default;
+}
+async function newWidgetsHistogram(properties) {
+    const ModConstructor = await importWidgetsHistogram();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHistogramRangeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/HistogramRangeSlider");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/HistogramRangeSlider.js')); });
+    return module.default;
+}
+async function newWidgetsHistogramRangeSlider(properties) {
+    const ModConstructor = await importWidgetsHistogramRangeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsHome() {
+    if (amd) {
+        return requireModule("esri/widgets/Home");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Home.js')); });
+    return module.default;
+}
+async function newWidgetsHome(properties) {
+    const ModConstructor = await importWidgetsHome();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLayerList() {
+    if (amd) {
+        return requireModule("esri/widgets/LayerList");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/LayerList.js')); });
+    return module.default;
+}
+async function newWidgetsLayerList(properties) {
+    const ModConstructor = await importWidgetsLayerList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLegend() {
+    if (amd) {
+        return requireModule("esri/widgets/Legend");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Legend.js')); });
+    return module.default;
+}
+async function newWidgetsLegend(properties) {
+    const ModConstructor = await importWidgetsLegend();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLineOfSight() {
+    if (amd) {
+        return requireModule("esri/widgets/LineOfSight");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/LineOfSight.js')); });
+    return module.default;
+}
+async function newWidgetsLineOfSight(properties) {
+    const ModConstructor = await importWidgetsLineOfSight();
+    return new ModConstructor(properties);
+}
+async function importWidgetsLocate() {
+    if (amd) {
+        return requireModule("esri/widgets/Locate");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Locate.js')); });
+    return module.default;
+}
+async function newWidgetsLocate(properties) {
+    const ModConstructor = await importWidgetsLocate();
+    return new ModConstructor(properties);
+}
+async function importWidgetsMeasurement() {
+    if (amd) {
+        return requireModule("esri/widgets/Measurement");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Measurement.js')); });
+    return module.default;
+}
+async function newWidgetsMeasurement(properties) {
+    const ModConstructor = await importWidgetsMeasurement();
+    return new ModConstructor(properties);
+}
+async function importWidgetsNavigationToggle() {
+    if (amd) {
+        return requireModule("esri/widgets/NavigationToggle");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/NavigationToggle.js')); });
+    return module.default;
+}
+async function newWidgetsNavigationToggle(properties) {
+    const ModConstructor = await importWidgetsNavigationToggle();
+    return new ModConstructor(properties);
+}
+async function importWidgetsPrint() {
+    if (amd) {
+        return requireModule("esri/widgets/Print");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Print.js')); });
+    return module.default;
+}
+async function newWidgetsPrint(properties) {
+    const ModConstructor = await importWidgetsPrint();
+    return new ModConstructor(properties);
+}
+async function importWidgetsScaleBar() {
+    if (amd) {
+        return requireModule("esri/widgets/ScaleBar");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/ScaleBar.js')); });
+    return module.default;
+}
+async function newWidgetsScaleBar(properties) {
+    const ModConstructor = await importWidgetsScaleBar();
+    return new ModConstructor(properties);
+}
+async function importWidgetsScaleRangeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/ScaleRangeSlider");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/ScaleRangeSlider.js')); });
+    return module.default;
+}
+async function newWidgetsScaleRangeSlider(properties) {
+    const ModConstructor = await importWidgetsScaleRangeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSearch() {
+    if (amd) {
+        return requireModule("esri/widgets/Search");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Search.js')); });
+    return module.default;
+}
+async function newWidgetsSearch(properties) {
+    const ModConstructor = await importWidgetsSearch();
+    return new ModConstructor(properties);
+}
+async function importWidgetsShadowCast() {
+    if (amd) {
+        return requireModule("esri/widgets/ShadowCast");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/ShadowCast.js')); });
+    return module.default;
+}
+async function newWidgetsShadowCast(properties) {
+    const ModConstructor = await importWidgetsShadowCast();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSketch() {
+    if (amd) {
+        return requireModule("esri/widgets/Sketch");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Sketch.js')); });
+    return module.default;
+}
+async function newWidgetsSketch(properties) {
+    const ModConstructor = await importWidgetsSketch();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSlice() {
+    if (amd) {
+        return requireModule("esri/widgets/Slice");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Slice.js')); });
+    return module.default;
+}
+async function newWidgetsSlice(properties) {
+    const ModConstructor = await importWidgetsSlice();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/Slider");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Slider.js')); });
+    return module.default;
+}
+async function newWidgetsSlider(properties) {
+    const ModConstructor = await importWidgetsSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsSwipe() {
+    if (amd) {
+        return requireModule("esri/widgets/Swipe");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Swipe.js')); });
+    return module.default;
+}
+async function newWidgetsSwipe(properties) {
+    const ModConstructor = await importWidgetsSwipe();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTableList() {
+    if (amd) {
+        return requireModule("esri/widgets/TableList");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/TableList.js')); });
+    return module.default;
+}
+async function newWidgetsTableList(properties) {
+    const ModConstructor = await importWidgetsTableList();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTimeSlider() {
+    if (amd) {
+        return requireModule("esri/widgets/TimeSlider");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/TimeSlider.js')); });
+    return module.default;
+}
+async function newWidgetsTimeSlider(properties) {
+    const ModConstructor = await importWidgetsTimeSlider();
+    return new ModConstructor(properties);
+}
+async function importWidgetsTrack() {
+    if (amd) {
+        return requireModule("esri/widgets/Track");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Track.js')); });
+    return module.default;
+}
+async function newWidgetsTrack(properties) {
+    const ModConstructor = await importWidgetsTrack();
+    return new ModConstructor(properties);
+}
+async function importWidgetsUtilityNetworkAssociations() {
+    if (amd) {
+        return requireModule("esri/widgets/UtilityNetworkAssociations");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/UtilityNetworkAssociations.js')); });
+    return module.default;
+}
+async function newWidgetsUtilityNetworkAssociations(properties) {
+    const ModConstructor = await importWidgetsUtilityNetworkAssociations();
+    return new ModConstructor(properties);
+}
+async function importWidgetsUtilityNetworkTrace() {
+    if (amd) {
+        return requireModule("esri/widgets/UtilityNetworkTrace");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/UtilityNetworkTrace.js')); });
+    return module.default;
+}
+async function newWidgetsUtilityNetworkTrace(properties) {
+    const ModConstructor = await importWidgetsUtilityNetworkTrace();
+    return new ModConstructor(properties);
+}
+async function importWidgetsUtilityNetworkValidateTopology() {
+    if (amd) {
+        return requireModule("esri/widgets/UtilityNetworkValidateTopology");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/UtilityNetworkValidateTopology.js')); });
+    return module.default;
+}
+async function newWidgetsUtilityNetworkValidateTopology(properties) {
+    const ModConstructor = await importWidgetsUtilityNetworkValidateTopology();
+    return new ModConstructor(properties);
+}
+async function importWidgetsValuePicker() {
+    if (amd) {
+        return requireModule("esri/widgets/ValuePicker");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/ValuePicker.js')); });
+    return module.default;
+}
+async function newWidgetsValuePicker(properties) {
+    const ModConstructor = await importWidgetsValuePicker();
+    return new ModConstructor(properties);
+}
+async function importWidgetsWeather() {
+    if (amd) {
+        return requireModule("esri/widgets/Weather");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Weather.js')); });
+    return module.default;
+}
+async function newWidgetsWeather(properties) {
+    const ModConstructor = await importWidgetsWeather();
+    return new ModConstructor(properties);
+}
+async function importWidgetsZoom() {
+    if (amd) {
+        return requireModule("esri/widgets/Zoom");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/widgets/Zoom.js')); });
+    return module.default;
+}
+async function newWidgetsZoom(properties) {
+    const ModConstructor = await importWidgetsZoom();
+    return new ModConstructor(properties);
+}
+async function importCoreReactiveUtils() {
+    if (amd) {
+        return requireModule("esri/core/reactiveUtils");
+    }
+    const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/core/reactiveUtils.js')); });
+    return module;
+}
+
+exports.importCoreReactiveUtils = importCoreReactiveUtils;
+exports.newLayersFeatureLayer = newLayersFeatureLayer;
+exports.newLayersGraphicsLayer = newLayersGraphicsLayer;
+exports.newLayersRouteLayer = newLayersRouteLayer;
+exports.newViewsMapView = newViewsMapView;
+exports.newViewsSceneView = newViewsSceneView;
+exports.newWebMap = newWebMap;
+exports.newWebScene = newWebScene;
+exports.newWidgetsAreaMeasurement2D = newWidgetsAreaMeasurement2D;
+exports.newWidgetsAreaMeasurement3D = newWidgetsAreaMeasurement3D;
+exports.newWidgetsAttachments = newWidgetsAttachments;
+exports.newWidgetsBasemapGallery = newWidgetsBasemapGallery;
+exports.newWidgetsBasemapLayerList = newWidgetsBasemapLayerList;
+exports.newWidgetsBasemapToggle = newWidgetsBasemapToggle;
+exports.newWidgetsBookmarks = newWidgetsBookmarks;
+exports.newWidgetsBuildingExplorer = newWidgetsBuildingExplorer;
+exports.newWidgetsCompass = newWidgetsCompass;
+exports.newWidgetsCoordinateConversion = newWidgetsCoordinateConversion;
+exports.newWidgetsDaylight = newWidgetsDaylight;
+exports.newWidgetsDirectLineMeasurement3D = newWidgetsDirectLineMeasurement3D;
+exports.newWidgetsDirections = newWidgetsDirections;
+exports.newWidgetsDistanceMeasurement2D = newWidgetsDistanceMeasurement2D;
+exports.newWidgetsEditor = newWidgetsEditor;
+exports.newWidgetsElevationProfile = newWidgetsElevationProfile;
+exports.newWidgetsExpand = newWidgetsExpand;
+exports.newWidgetsFeature = newWidgetsFeature;
+exports.newWidgetsFeatureForm = newWidgetsFeatureForm;
+exports.newWidgetsFeatureTable = newWidgetsFeatureTable;
+exports.newWidgetsFeatureTemplates = newWidgetsFeatureTemplates;
+exports.newWidgetsFeatures = newWidgetsFeatures;
+exports.newWidgetsFloorFilter = newWidgetsFloorFilter;
+exports.newWidgetsFullscreen = newWidgetsFullscreen;
+exports.newWidgetsHistogram = newWidgetsHistogram;
+exports.newWidgetsHistogramRangeSlider = newWidgetsHistogramRangeSlider;
+exports.newWidgetsHome = newWidgetsHome;
+exports.newWidgetsLayerList = newWidgetsLayerList;
+exports.newWidgetsLegend = newWidgetsLegend;
+exports.newWidgetsLineOfSight = newWidgetsLineOfSight;
+exports.newWidgetsLocate = newWidgetsLocate;
+exports.newWidgetsMeasurement = newWidgetsMeasurement;
+exports.newWidgetsNavigationToggle = newWidgetsNavigationToggle;
+exports.newWidgetsPrint = newWidgetsPrint;
+exports.newWidgetsScaleBar = newWidgetsScaleBar;
+exports.newWidgetsScaleRangeSlider = newWidgetsScaleRangeSlider;
+exports.newWidgetsSearch = newWidgetsSearch;
+exports.newWidgetsShadowCast = newWidgetsShadowCast;
+exports.newWidgetsSketch = newWidgetsSketch;
+exports.newWidgetsSlice = newWidgetsSlice;
+exports.newWidgetsSlider = newWidgetsSlider;
+exports.newWidgetsSwipe = newWidgetsSwipe;
+exports.newWidgetsTableList = newWidgetsTableList;
+exports.newWidgetsTimeSlider = newWidgetsTimeSlider;
+exports.newWidgetsTrack = newWidgetsTrack;
+exports.newWidgetsUtilityNetworkAssociations = newWidgetsUtilityNetworkAssociations;
+exports.newWidgetsUtilityNetworkTrace = newWidgetsUtilityNetworkTrace;
+exports.newWidgetsUtilityNetworkValidateTopology = newWidgetsUtilityNetworkValidateTopology;
+exports.newWidgetsValuePicker = newWidgetsValuePicker;
+exports.newWidgetsWeather = newWidgetsWeather;
+exports.newWidgetsZoom = newWidgetsZoom;
+
+//# sourceMappingURL=index-09a0e90f.js.map