@esri/solutions-components 0.0.2 → 0.0.9

package/dist/esm/request-9c2c9a49.js

@@ -0,0 +1,548 @@
+/*!
+ * Copyright 2021 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+/**
+ * Checks parameters to see if we should use FormData to send the request
+ * @param params The object whose keys will be encoded.
+ * @return A boolean indicating if FormData will be required.
+ */
+function requiresFormData(params) {
+    return Object.keys(params).some(function (key) {
+        var value = params[key];
+        if (!value) {
+            return false;
+        }
+        if (value && value.toParam) {
+            value = value.toParam();
+        }
+        var type = value.constructor.name;
+        switch (type) {
+            case "Array":
+                return false;
+            case "Object":
+                return false;
+            case "Date":
+                return false;
+            case "Function":
+                return false;
+            case "Boolean":
+                return false;
+            case "String":
+                return false;
+            case "Number":
+                return false;
+            default:
+                return true;
+        }
+    });
+}
+/**
+ * Converts parameters to the proper representation to send to the ArcGIS REST API.
+ * @param params The object whose keys will be encoded.
+ * @return A new object with properly encoded values.
+ */
+function processParams(params) {
+    var newParams = {};
+    Object.keys(params).forEach(function (key) {
+        var _a, _b;
+        var param = params[key];
+        if (param && param.toParam) {
+            param = param.toParam();
+        }
+        if (!param &&
+            param !== 0 &&
+            typeof param !== "boolean" &&
+            typeof param !== "string") {
+            return;
+        }
+        var type = param.constructor.name;
+        var value;
+        // properly encodes objects, arrays and dates for arcgis.com and other services.
+        // ported from https://github.com/Esri/esri-leaflet/blob/master/src/Request.js#L22-L30
+        // also see https://github.com/Esri/arcgis-rest-js/issues/18:
+        // null, undefined, function are excluded. If you want to send an empty key you need to send an empty string "".
+        switch (type) {
+            case "Array":
+                // Based on the first element of the array, classify array as an array of arrays, an array of objects
+                // to be stringified, or an array of non-objects to be comma-separated
+                // eslint-disable-next-line no-case-declarations
+                var firstElementType = (_b = (_a = param[0]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                value =
+                    firstElementType === "Array" ? param : // pass thru array of arrays
+                        firstElementType === "Object" ? JSON.stringify(param) : // stringify array of objects
+                            param.join(","); // join other types of array elements
+                break;
+            case "Object":
+                value = JSON.stringify(param);
+                break;
+            case "Date":
+                value = param.valueOf();
+                break;
+            case "Function":
+                value = null;
+                break;
+            case "Boolean":
+                value = param + "";
+                break;
+            default:
+                value = param;
+                break;
+        }
+        if (value || value === 0 || typeof value === "string" || Array.isArray(value)) {
+            newParams[key] = value;
+        }
+    });
+    return newParams;
+}
+
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+/**
+ * Encodes keys and parameters for use in a URL's query string.
+ *
+ * @param key Parameter's key
+ * @param value Parameter's value
+ * @returns Query string with key and value pairs separated by "&"
+ */
+function encodeParam(key, value) {
+    // For array of arrays, repeat key=value for each element of containing array
+    if (Array.isArray(value) && value[0] && Array.isArray(value[0])) {
+        return value.map(function (arrayElem) { return encodeParam(key, arrayElem); }).join("&");
+    }
+    return encodeURIComponent(key) + "=" + encodeURIComponent(value);
+}
+/**
+ * Encodes the passed object as a query string.
+ *
+ * @param params An object to be encoded.
+ * @returns An encoded query string.
+ */
+function encodeQueryString(params) {
+    var newParams = processParams(params);
+    return Object.keys(newParams)
+        .map(function (key) {
+        return encodeParam(key, newParams[key]);
+    })
+        .join("&");
+}
+
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+/**
+ * Encodes parameters in a [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object in browsers or in a [FormData](https://github.com/form-data/form-data) in Node.js
+ *
+ * @param params An object to be encoded.
+ * @returns The complete [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object.
+ */
+function encodeFormData(params, forceFormData) {
+    // see https://github.com/Esri/arcgis-rest-js/issues/499 for more info.
+    var useFormData = requiresFormData(params) || forceFormData;
+    var newParams = processParams(params);
+    if (useFormData) {
+        var formData_1 = new FormData();
+        Object.keys(newParams).forEach(function (key) {
+            if (typeof Blob !== "undefined" && newParams[key] instanceof Blob) {
+                /* To name the Blob:
+                 1. look to an alternate request parameter called 'fileName'
+                 2. see if 'name' has been tacked onto the Blob manually
+                 3. if all else fails, use the request parameter
+                */
+                var filename = newParams["fileName"] || newParams[key].name || key;
+                formData_1.append(key, newParams[key], filename);
+            }
+            else {
+                formData_1.append(key, newParams[key]);
+            }
+        });
+        return formData_1;
+    }
+    else {
+        return encodeQueryString(params);
+    }
+}
+
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+// TypeScript 2.1 no longer allows you to extend built in types. See https://github.com/Microsoft/TypeScript/issues/12790#issuecomment-265981442
+// and https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+//
+// This code is from MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types.
+var ArcGISRequestError = /** @class */ (function () {
+    /**
+     * Create a new `ArcGISRequestError`  object.
+     *
+     * @param message - The error message from the API
+     * @param code - The error code from the API
+     * @param response - The original response from the API that caused the error
+     * @param url - The original url of the request
+     * @param options - The original options and parameters of the request
+     */
+    function ArcGISRequestError(message, code, response, url, options) {
+        message = message || "UNKNOWN_ERROR";
+        code = code || "UNKNOWN_ERROR_CODE";
+        this.name = "ArcGISRequestError";
+        this.message =
+            code === "UNKNOWN_ERROR_CODE" ? message : code + ": " + message;
+        this.originalMessage = message;
+        this.code = code;
+        this.response = response;
+        this.url = url;
+        this.options = options;
+    }
+    return ArcGISRequestError;
+}());
+ArcGISRequestError.prototype = Object.create(Error.prototype);
+ArcGISRequestError.prototype.constructor = ArcGISRequestError;
+
+/* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+var NODEJS_DEFAULT_REFERER_HEADER = "@esri/arcgis-rest-js";
+var DEFAULT_ARCGIS_REQUEST_OPTIONS = {
+    httpMethod: "POST",
+    params: {
+        f: "json",
+    },
+};
+var ArcGISAuthError = /** @class */ (function (_super) {
+    __extends(ArcGISAuthError, _super);
+    /**
+     * Create a new `ArcGISAuthError`  object.
+     *
+     * @param message - The error message from the API
+     * @param code - The error code from the API
+     * @param response - The original response from the API that caused the error
+     * @param url - The original url of the request
+     * @param options - The original options of the request
+     */
+    function ArcGISAuthError(message, code, response, url, options) {
+        if (message === void 0) { message = "AUTHENTICATION_ERROR"; }
+        if (code === void 0) { code = "AUTHENTICATION_ERROR_CODE"; }
+        var _this = _super.call(this, message, code, response, url, options) || this;
+        _this.name = "ArcGISAuthError";
+        _this.message =
+            code === "AUTHENTICATION_ERROR_CODE" ? message : code + ": " + message;
+        return _this;
+    }
+    ArcGISAuthError.prototype.retry = function (getSession, retryLimit) {
+        var _this = this;
+        if (retryLimit === void 0) { retryLimit = 3; }
+        var tries = 0;
+        var retryRequest = function (resolve, reject) {
+            getSession(_this.url, _this.options)
+                .then(function (session) {
+                var newOptions = __assign(__assign({}, _this.options), { authentication: session });
+                tries = tries + 1;
+                return request(_this.url, newOptions);
+            })
+                .then(function (response) {
+                resolve(response);
+            })
+                .catch(function (e) {
+                if (e.name === "ArcGISAuthError" && tries < retryLimit) {
+                    retryRequest(resolve, reject);
+                }
+                else if (e.name === "ArcGISAuthError" && tries >= retryLimit) {
+                    reject(_this);
+                }
+                else {
+                    reject(e);
+                }
+            });
+        };
+        return new Promise(function (resolve, reject) {
+            retryRequest(resolve, reject);
+        });
+    };
+    return ArcGISAuthError;
+}(ArcGISRequestError));
+/**
+ * Checks for errors in a JSON response from the ArcGIS REST API. If there are no errors, it will return the `data` passed in. If there is an error, it will throw an `ArcGISRequestError` or `ArcGISAuthError`.
+ *
+ * @param data The response JSON to check for errors.
+ * @param url The url of the original request
+ * @param params The parameters of the original request
+ * @param options The options of the original request
+ * @returns The data that was passed in the `data` parameter
+ */
+function checkForErrors(response, url, params, options, originalAuthError) {
+    // this is an error message from billing.arcgis.com backend
+    if (response.code >= 400) {
+        var message = response.message, code = response.code;
+        throw new ArcGISRequestError(message, code, response, url, options);
+    }
+    // error from ArcGIS Online or an ArcGIS Portal or server instance.
+    if (response.error) {
+        var _a = response.error, message = _a.message, code = _a.code, messageCode = _a.messageCode;
+        var errorCode = messageCode || code || "UNKNOWN_ERROR_CODE";
+        if (code === 498 ||
+            code === 499 ||
+            messageCode === "GWM_0003" ||
+            (code === 400 && message === "Unable to generate token.")) {
+            if (originalAuthError) {
+                throw originalAuthError;
+            }
+            else {
+                throw new ArcGISAuthError(message, errorCode, response, url, options);
+            }
+        }
+        throw new ArcGISRequestError(message, errorCode, response, url, options);
+    }
+    // error from a status check
+    if (response.status === "failed" || response.status === "failure") {
+        var message = void 0;
+        var code = "UNKNOWN_ERROR_CODE";
+        try {
+            message = JSON.parse(response.statusMessage).message;
+            code = JSON.parse(response.statusMessage).code;
+        }
+        catch (e) {
+            message = response.statusMessage || response.message;
+        }
+        throw new ArcGISRequestError(message, code, response, url, options);
+    }
+    return response;
+}
+/**
+ * ```js
+ * import { request } from '@esri/arcgis-rest-request';
+ * //
+ * request('https://www.arcgis.com/sharing/rest')
+ *   .then(response) // response.currentVersion === 5.2
+ * //
+ * request('https://www.arcgis.com/sharing/rest', {
+ *   httpMethod: "GET"
+ * })
+ * //
+ * request('https://www.arcgis.com/sharing/rest/search', {
+ *   params: { q: 'parks' }
+ * })
+ *   .then(response) // response.total => 78379
+ * ```
+ * Generic method for making HTTP requests to ArcGIS REST API endpoints.
+ *
+ * @param url - The URL of the ArcGIS REST API endpoint.
+ * @param requestOptions - Options for the request, including parameters relevant to the endpoint.
+ * @returns A Promise that will resolve with the data from the response.
+ */
+function request(url, requestOptions) {
+    if (requestOptions === void 0) { requestOptions = { params: { f: "json" } }; }
+    var options = __assign(__assign(__assign({ httpMethod: "POST" }, DEFAULT_ARCGIS_REQUEST_OPTIONS), requestOptions), {
+        params: __assign(__assign({}, DEFAULT_ARCGIS_REQUEST_OPTIONS.params), requestOptions.params),
+        headers: __assign(__assign({}, DEFAULT_ARCGIS_REQUEST_OPTIONS.headers), requestOptions.headers),
+    });
+    var missingGlobals = [];
+    var recommendedPackages = [];
+    // don't check for a global fetch if a custom implementation was passed through
+    if (!options.fetch && typeof fetch !== "undefined") {
+        options.fetch = fetch.bind(Function("return this")());
+    }
+    else {
+        missingGlobals.push("`fetch`");
+        recommendedPackages.push("`node-fetch`");
+    }
+    if (typeof Promise === "undefined") {
+        missingGlobals.push("`Promise`");
+        recommendedPackages.push("`es6-promise`");
+    }
+    if (typeof FormData === "undefined") {
+        missingGlobals.push("`FormData`");
+        recommendedPackages.push("`isomorphic-form-data`");
+    }
+    if (!options.fetch ||
+        typeof Promise === "undefined" ||
+        typeof FormData === "undefined") {
+        throw new Error("`arcgis-rest-request` requires a `fetch` implementation and global variables for `Promise` and `FormData` to be present in the global scope. You are missing " + missingGlobals.join(", ") + ". We recommend installing the " + recommendedPackages.join(", ") + " modules at the root of your application to add these to the global scope. See https://bit.ly/2KNwWaJ for more info.");
+    }
+    var httpMethod = options.httpMethod, authentication = options.authentication, rawResponse = options.rawResponse;
+    var params = __assign({ f: "json" }, options.params);
+    var originalAuthError = null;
+    var fetchOptions = {
+        method: httpMethod,
+        /* ensures behavior mimics XMLHttpRequest.
+        needed to support sending IWA cookies */
+        credentials: options.credentials || "same-origin",
+    };
+    // the /oauth2/platformSelf route will add X-Esri-Auth-Client-Id header
+    // and that request needs to send cookies cross domain
+    // so we need to set the credentials to "include"
+    if (options.headers &&
+        options.headers["X-Esri-Auth-Client-Id"] &&
+        url.indexOf("/oauth2/platformSelf") > -1) {
+        fetchOptions.credentials = "include";
+    }
+    return (authentication
+        ? authentication.getToken(url, { fetch: options.fetch }).catch(function (err) {
+            /**
+             * append original request url and requestOptions
+             * to the error thrown by getToken()
+             * to assist with retrying
+             */
+            err.url = url;
+            err.options = options;
+            /**
+             * if an attempt is made to talk to an unfederated server
+             * first try the request anonymously. if a 'token required'
+             * error is thrown, throw the UNFEDERATED error then.
+             */
+            originalAuthError = err;
+            return Promise.resolve("");
+        })
+        : Promise.resolve(""))
+        .then(function (token) {
+        if (token.length) {
+            params.token = token;
+        }
+        if (authentication && authentication.getDomainCredentials) {
+            fetchOptions.credentials = authentication.getDomainCredentials(url);
+        }
+        // Custom headers to add to request. IRequestOptions.headers with merge over requestHeaders.
+        var requestHeaders = {};
+        if (fetchOptions.method === "GET") {
+            // Prevents token from being passed in query params when hideToken option is used.
+            /* istanbul ignore if - window is always defined in a browser. Test case is covered by Jasmine in node test */
+            if (params.token &&
+                options.hideToken &&
+                // Sharing API does not support preflight check required by modern browsers https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request
+                typeof window === "undefined") {
+                requestHeaders["X-Esri-Authorization"] = "Bearer " + params.token;
+                delete params.token;
+            }
+            // encode the parameters into the query string
+            var queryParams = encodeQueryString(params);
+            // dont append a '?' unless parameters are actually present
+            var urlWithQueryString = queryParams === "" ? url : url + "?" + encodeQueryString(params);
+            if (
+            // This would exceed the maximum length for URLs specified by the consumer and requires POST
+            (options.maxUrlLength &&
+                urlWithQueryString.length > options.maxUrlLength) ||
+                // Or if the customer requires the token to be hidden and it has not already been hidden in the header (for browsers)
+                (params.token && options.hideToken)) {
+                // the consumer specified a maximum length for URLs
+                // and this would exceed it, so use post instead
+                fetchOptions.method = "POST";
+                // If the token was already added as a Auth header, add the token back to body with other params instead of header
+                if (token.length && options.hideToken) {
+                    params.token = token;
+                    // Remove existing header that was added before url query length was checked
+                    delete requestHeaders["X-Esri-Authorization"];
+                }
+            }
+            else {
+                // just use GET
+                url = urlWithQueryString;
+            }
+        }
+        /* updateResources currently requires FormData even when the input parameters dont warrant it.
+    https://developers.arcgis.com/rest/users-groups-and-items/update-resources.htm
+        see https://github.com/Esri/arcgis-rest-js/pull/500 for more info. */
+        var forceFormData = new RegExp("/items/.+/updateResources").test(url);
+        if (fetchOptions.method === "POST") {
+            fetchOptions.body = encodeFormData(params, forceFormData);
+        }
+        // Mixin headers from request options
+        fetchOptions.headers = __assign(__assign({}, requestHeaders), options.headers);
+        /* istanbul ignore next - karma reports coverage on browser tests only */
+        if (typeof window === "undefined" && !fetchOptions.headers.referer) {
+            fetchOptions.headers.referer = NODEJS_DEFAULT_REFERER_HEADER;
+        }
+        /* istanbul ignore else blob responses are difficult to make cross platform we will just have to trust the isomorphic fetch will do its job */
+        if (!requiresFormData(params) && !forceFormData) {
+            fetchOptions.headers["Content-Type"] =
+                "application/x-www-form-urlencoded";
+        }
+        return options.fetch(url, fetchOptions);
+    })
+        .then(function (response) {
+        if (!response.ok) {
+            // server responded w/ an actual error (404, 500, etc)
+            var status_1 = response.status, statusText = response.statusText;
+            throw new ArcGISRequestError(statusText, "HTTP " + status_1, response, url, options);
+        }
+        if (rawResponse) {
+            return response;
+        }
+        switch (params.f) {
+            case "json":
+                return response.json();
+            case "geojson":
+                return response.json();
+            case "html":
+                return response.text();
+            case "text":
+                return response.text();
+            /* istanbul ignore next blob responses are difficult to make cross platform we will just have to trust that isomorphic fetch will do its job */
+            default:
+                return response.blob();
+        }
+    })
+        .then(function (data) {
+        if ((params.f === "json" || params.f === "geojson") && !rawResponse) {
+            var response = checkForErrors(data, url, params, options, originalAuthError);
+            if (originalAuthError) {
+                /* If the request was made to an unfederated service that
+                didn't require authentication, add the base url and a dummy token
+                to the list of trusted servers to avoid another federation check
+                in the event of a repeat request */
+                var truncatedUrl = url
+                    .toLowerCase()
+                    .split(/\/rest(\/admin)?\/services\//)[0];
+                options.authentication.federatedServers[truncatedUrl] = {
+                    token: [],
+                    // default to 24 hours
+                    expires: new Date(Date.now() + 86400 * 1000),
+                };
+                originalAuthError = null;
+            }
+            return response;
+        }
+        else {
+            return data;
+        }
+    });
+}
+
+export { __assign as _, request as r };

package/dist/esm/resources-12c3b829.js

@@ -19,5 +19,3 @@ const ICONS = {
 };
 
 export { ICONS as I, SLOTS as S, TEXT as T };
-
-//# sourceMappingURL=resources-12c3b829.js.map

package/dist/esm/resources-32d7dd89.js

@@ -27,5 +27,3 @@ const ARIA_EXPANDED = "aria-expanded";
 const HEADING_LEVEL = 2;
 
 export { ARIA_EXPANDED as A, CSS as C, HEADING_LEVEL as H, POPOVER_REFERENCE as P, TEXT as T, ARIA_CONTROLS as a };
-
-//# sourceMappingURL=resources-32d7dd89.js.map

package/dist/esm/resources-466ccf86.js

@@ -21,5 +21,3 @@ const SLOTS = {
 };
 
 export { CSS as C, ICON_TYPES as I, SLOTS as S };
-
-//# sourceMappingURL=resources-466ccf86.js.map

package/dist/esm/resources-4cc0ef44.js

@@ -35,5 +35,3 @@ const TEXT = {
 };
 
 export { CSS as C, ICONS as I, SLOTS as S, TEXT as T };
-
-//# sourceMappingURL=resources-4cc0ef44.js.map

package/dist/esm/resources-861d0240.js

@@ -35,5 +35,3 @@ const TEXT = {
 const HEADING_LEVEL = 2;
 
 export { CSS as C, HEADING_LEVEL as H, ICONS as I, TEXT as T };
-
-//# sourceMappingURL=resources-861d0240.js.map

package/dist/esm/resources-b023c30a.js

@@ -20,5 +20,3 @@ const ICONS = {
 };
 
 export { CSS as C, ICONS as I, SLOTS as S };
-
-//# sourceMappingURL=resources-b023c30a.js.map

package/dist/esm/{resources-c537bacb.js → resources-d7e09977.js}

@@ -3,7 +3,7 @@
  * Licensed under the Apache License, Version 2.0
  * http://www.apache.org/licenses/LICENSE-2.0
  */
-import { c as color } from './index-934f242e.js';
+import { c as color } from './index-c1264d13.js';
 
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
@@ -111,5 +111,3 @@ const DIMENSIONS = {
 };
 
 export { CSS as C, DEFAULT_COLOR as D, HSV_LIMITS as H, RGB_LIMITS as R, TEXT as T, DIMENSIONS as a, DEFAULT_STORAGE_KEY_PREFIX as b };
-
-//# sourceMappingURL=resources-c537bacb.js.map

package/dist/esm/resources-e56b6e53.js

@@ -69,5 +69,3 @@ const TEXT = {
 };
 
 export { HEADING_LEVEL as H, TEXT as T, getLocaleData as g };
-
-//# sourceMappingURL=resources-e56b6e53.js.map

package/dist/esm/resources-ec79cfd7.js

@@ -16,5 +16,3 @@ const TOOLTIP_REFERENCE = "data-calcite-tooltip-reference";
 const ARIA_DESCRIBED_BY = "aria-describedby";
 
 export { ARIA_DESCRIBED_BY as A, CSS as C, TOOLTIP_REFERENCE as T, TOOLTIP_DELAY_MS as a };
-
-//# sourceMappingURL=resources-ec79cfd7.js.map

package/dist/esm/shared-list-render-b5dacd2e.js

@@ -293,5 +293,3 @@ const List = (_a) => {
 };
 
 export { List as L, initializeObserver as a, calciteListItemChangeHandler as b, cleanUpObserver as c, deselectSiblingItems as d, calciteListItemValueChangeHandler as e, calciteListFocusOutHandler as f, getItemData as g, handleFilter as h, initialize as i, setUpItems as j, keyDownHandler as k, setFocus as l, mutationObserverCallback as m, removeItem as r, selectSiblings as s };
-
-//# sourceMappingURL=shared-list-render-b5dacd2e.js.map