@ionic/core 8.7.17-dev.11771959013.18adabe2 → 8.7.17-dev.11772030258.1ee4f499

package/components/index3.js

@@ -1,4 +1,455 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import{G as t}from"./gesture-controller.js";const e=(t,e,n,r)=>{const s=!!o(t)&&{capture:!1,passive:!!r.passive};let i,c;return t.__zone_symbol__addEventListener?(i="__zone_symbol__addEventListener",c="__zone_symbol__removeEventListener"):(i="addEventListener",c="removeEventListener"),t[i](e,n,s),()=>{t[c](e,n,s)}},o=t=>{if(void 0===n)try{const e=Object.defineProperty({},"passive",{get:()=>{n=!0}});t.addEventListener("optsTest",(()=>{}),e)}catch(t){n=!1}return!!n};let n;const r=t=>t instanceof Document?t:t.ownerDocument,s=o=>{let n=!1,s=!1,u=!0,d=!1;const l=Object.assign({disableScroll:!1,direction:"x",gesturePriority:0,passive:!0,maxAngle:40,threshold:10},o),v=l.canStart,m=l.onWillStart,p=l.onStart,f=l.onEnd,y=l.notCaptured,h=l.onMove,_=l.threshold,b=l.passive,g=l.blurOnStart,D={type:"pan",startX:0,startY:0,startTime:0,currentX:0,currentY:0,velocityX:0,velocityY:0,deltaX:0,deltaY:0,currentTime:0,event:void 0,data:void 0},x=((t,e,o)=>{const n=o*(Math.PI/180),r="x"===t,s=Math.cos(n),i=e*e;let c=0,a=0,u=!1,d=0;return{start(t,e){c=t,a=e,d=0,u=!0},detect(t,e){if(!u)return!1;const o=t-c,n=e-a,l=o*o+n*n;if(l<i)return!1;const v=Math.sqrt(l),m=(r?o:n)/v;return d=m>s?1:m<-s?-1:0,u=!1,!0},isGesture:()=>0!==d,getDirection:()=>d}})(l.direction,l.threshold,l.maxAngle),E=t.createGesture({name:o.gestureName,priority:o.gesturePriority,disableScroll:o.disableScroll}),L=()=>{n&&(d=!1,h&&h(D))},X=()=>!!E.capture()&&(n=!0,u=!1,D.startX=D.currentX,D.startY=D.currentY,D.startTime=D.currentTime,m?m(D).then(Y):Y(),!0),Y=()=>{g&&(()=>{if("undefined"!=typeof document){const t=document.activeElement;(null==t?void 0:t.blur)&&t.blur()}})(),p&&p(D),u=!0},j=()=>{n=!1,s=!1,d=!1,u=!0,E.release()},M=t=>{const e=n,o=u;j(),o&&(i(D,t),e?f&&f(D):y&&y(D))},T=((t,o,n,s,i)=>{let c,a,u,d,l,v,m,p=0;const f=r=>{p=Date.now()+2e3,o(r)&&(!a&&n&&(a=e(t,"touchmove",n,i)),u||(u=e(r.target,"touchend",h,i)),d||(d=e(r.target,"touchcancel",h,i)))},y=s=>{p>Date.now()||o(s)&&(!v&&n&&(v=e(r(t),"mousemove",n,i)),m||(m=e(r(t),"mouseup",_,i)))},h=t=>{b(),s&&s(t)},_=t=>{g(),s&&s(t)},b=()=>{a&&a(),u&&u(),d&&d(),a=u=d=void 0},g=()=>{v&&v(),m&&m(),v=m=void 0},D=()=>{b(),g()},x=(o=!0)=>{o?(c||(c=e(t,"touchstart",f,i)),l||(l=e(t,"mousedown",y,i))):(c&&c(),l&&l(),c=l=void 0,D())};return{enable:x,stop:D,destroy:()=>{x(!1),s=n=o=void 0}}})(l.el,(t=>{const e=a(t);return!(s||!u)&&(c(t,D),D.startX=D.currentX,D.startY=D.currentY,D.startTime=D.currentTime=e,D.velocityX=D.velocityY=D.deltaX=D.deltaY=0,D.event=t,(!v||!1!==v(D))&&(E.release(),!!E.start()&&(s=!0,0===_?X():(x.start(D.startX,D.startY),!0))))}),(t=>{n?!d&&u&&(d=!0,i(D,t),requestAnimationFrame(L)):(i(D,t),x.detect(D.currentX,D.currentY)&&(x.isGesture()&&X()||z()))}),M,{passive:b}),z=()=>{j(),T.stop(),y&&y(D)};return{enable(t=!0){t||(n&&M(void 0),j()),T.enable(t)},destroy(){E.destroy(),T.destroy()}}},i=(t,e)=>{if(!e)return;const o=t.currentX,n=t.currentY,r=t.currentTime;c(e,t);const s=t.currentX,i=t.currentY,u=(t.currentTime=a(e))-r;if(u>0&&u<100){const e=(i-n)/u;t.velocityX=(s-o)/u*.7+.3*t.velocityX,t.velocityY=.7*e+.3*t.velocityY}t.deltaX=s-t.startX,t.deltaY=i-t.startY,t.event=e},c=(t,e)=>{let o=0,n=0;if(t){const e=t.changedTouches;if(e&&e.length>0){const t=e[0];o=t.clientX,n=t.clientY}else void 0!==t.pageX&&(o=t.pageX,n=t.pageY)}e.currentX=o,e.currentY=n},a=t=>t.timeStamp||Date.now();export{t as GESTURE_CONTROLLER,s as createGesture}
+import { G as GESTURE_CONTROLLER } from './gesture-controller.js';
+
+const addEventListener = (el, // TODO(FW-2832): type
+eventName, callback, opts) => {
+    // use event listener options when supported
+    // otherwise it's just a boolean for the "capture" arg
+    const listenerOpts = supportsPassive(el)
+        ? {
+            capture: false,
+            passive: !!opts.passive,
+        }
+        : false;
+    let add;
+    let remove;
+    if (el['__zone_symbol__addEventListener']) {
+        add = '__zone_symbol__addEventListener';
+        remove = '__zone_symbol__removeEventListener';
+    }
+    else {
+        add = 'addEventListener';
+        remove = 'removeEventListener';
+    }
+    el[add](eventName, callback, listenerOpts);
+    return () => {
+        el[remove](eventName, callback, listenerOpts);
+    };
+};
+const supportsPassive = (node) => {
+    if (_sPassive === undefined) {
+        try {
+            const opts = Object.defineProperty({}, 'passive', {
+                get: () => {
+                    _sPassive = true;
+                },
+            });
+            node.addEventListener('optsTest', () => {
+                return;
+            }, opts);
+        }
+        catch (e) {
+            _sPassive = false;
+        }
+    }
+    return !!_sPassive;
+};
+let _sPassive;
+
+const MOUSE_WAIT = 2000;
+// TODO(FW-2832): types
+const createPointerEvents = (el, pointerDown, pointerMove, pointerUp, options) => {
+    let rmTouchStart;
+    let rmTouchMove;
+    let rmTouchEnd;
+    let rmTouchCancel;
+    let rmMouseStart;
+    let rmMouseMove;
+    let rmMouseUp;
+    let lastTouchEvent = 0;
+    const handleTouchStart = (ev) => {
+        lastTouchEvent = Date.now() + MOUSE_WAIT;
+        if (!pointerDown(ev)) {
+            return;
+        }
+        if (!rmTouchMove && pointerMove) {
+            rmTouchMove = addEventListener(el, 'touchmove', pointerMove, options);
+        }
+        /**
+         * Events are dispatched on the element that is tapped and bubble up to
+         * the reference element in the gesture. In the event that the element this
+         * event was first dispatched on is removed from the DOM, the event will no
+         * longer bubble up to our reference element. This leaves the gesture in an
+         * unusable state. To account for this, the touchend and touchcancel listeners
+         * should be added to the event target so that they still fire even if the target
+         * is removed from the DOM.
+         */
+        if (!rmTouchEnd) {
+            rmTouchEnd = addEventListener(ev.target, 'touchend', handleTouchEnd, options);
+        }
+        if (!rmTouchCancel) {
+            rmTouchCancel = addEventListener(ev.target, 'touchcancel', handleTouchEnd, options);
+        }
+    };
+    const handleMouseDown = (ev) => {
+        if (lastTouchEvent > Date.now()) {
+            return;
+        }
+        if (!pointerDown(ev)) {
+            return;
+        }
+        if (!rmMouseMove && pointerMove) {
+            rmMouseMove = addEventListener(getDocument(el), 'mousemove', pointerMove, options);
+        }
+        if (!rmMouseUp) {
+            rmMouseUp = addEventListener(getDocument(el), 'mouseup', handleMouseUp, options);
+        }
+    };
+    const handleTouchEnd = (ev) => {
+        stopTouch();
+        if (pointerUp) {
+            pointerUp(ev);
+        }
+    };
+    const handleMouseUp = (ev) => {
+        stopMouse();
+        if (pointerUp) {
+            pointerUp(ev);
+        }
+    };
+    const stopTouch = () => {
+        if (rmTouchMove) {
+            rmTouchMove();
+        }
+        if (rmTouchEnd) {
+            rmTouchEnd();
+        }
+        if (rmTouchCancel) {
+            rmTouchCancel();
+        }
+        rmTouchMove = rmTouchEnd = rmTouchCancel = undefined;
+    };
+    const stopMouse = () => {
+        if (rmMouseMove) {
+            rmMouseMove();
+        }
+        if (rmMouseUp) {
+            rmMouseUp();
+        }
+        rmMouseMove = rmMouseUp = undefined;
+    };
+    const stop = () => {
+        stopTouch();
+        stopMouse();
+    };
+    const enable = (isEnabled = true) => {
+        if (!isEnabled) {
+            if (rmTouchStart) {
+                rmTouchStart();
+            }
+            if (rmMouseStart) {
+                rmMouseStart();
+            }
+            rmTouchStart = rmMouseStart = undefined;
+            stop();
+        }
+        else {
+            if (!rmTouchStart) {
+                rmTouchStart = addEventListener(el, 'touchstart', handleTouchStart, options);
+            }
+            if (!rmMouseStart) {
+                rmMouseStart = addEventListener(el, 'mousedown', handleMouseDown, options);
+            }
+        }
+    };
+    const destroy = () => {
+        enable(false);
+        pointerUp = pointerMove = pointerDown = undefined;
+    };
+    return {
+        enable,
+        stop,
+        destroy,
+    };
+};
+const getDocument = (node) => {
+    return node instanceof Document ? node : node.ownerDocument;
+};
+
+const createPanRecognizer = (direction, thresh, maxAngle) => {
+    const radians = maxAngle * (Math.PI / 180);
+    const isDirX = direction === 'x';
+    const maxCosine = Math.cos(radians);
+    const threshold = thresh * thresh;
+    let startX = 0;
+    let startY = 0;
+    let dirty = false;
+    let isPan = 0;
+    return {
+        start(x, y) {
+            startX = x;
+            startY = y;
+            isPan = 0;
+            dirty = true;
+        },
+        detect(x, y) {
+            if (!dirty) {
+                return false;
+            }
+            const deltaX = x - startX;
+            const deltaY = y - startY;
+            const distance = deltaX * deltaX + deltaY * deltaY;
+            if (distance < threshold) {
+                return false;
+            }
+            const hypotenuse = Math.sqrt(distance);
+            const cosine = (isDirX ? deltaX : deltaY) / hypotenuse;
+            if (cosine > maxCosine) {
+                isPan = 1;
+            }
+            else if (cosine < -maxCosine) {
+                isPan = -1;
+            }
+            else {
+                isPan = 0;
+            }
+            dirty = false;
+            return true;
+        },
+        isGesture() {
+            return isPan !== 0;
+        },
+        getDirection() {
+            return isPan;
+        },
+    };
+};
+
+// TODO(FW-2832): types
+const createGesture = (config) => {
+    let hasCapturedPan = false;
+    let hasStartedPan = false;
+    let hasFiredStart = true;
+    let isMoveQueued = false;
+    const finalConfig = Object.assign({ disableScroll: false, direction: 'x', gesturePriority: 0, passive: true, maxAngle: 40, threshold: 10 }, config);
+    const canStart = finalConfig.canStart;
+    const onWillStart = finalConfig.onWillStart;
+    const onStart = finalConfig.onStart;
+    const onEnd = finalConfig.onEnd;
+    const notCaptured = finalConfig.notCaptured;
+    const onMove = finalConfig.onMove;
+    const threshold = finalConfig.threshold;
+    const passive = finalConfig.passive;
+    const blurOnStart = finalConfig.blurOnStart;
+    const detail = {
+        type: 'pan',
+        startX: 0,
+        startY: 0,
+        startTime: 0,
+        currentX: 0,
+        currentY: 0,
+        velocityX: 0,
+        velocityY: 0,
+        deltaX: 0,
+        deltaY: 0,
+        currentTime: 0,
+        event: undefined,
+        data: undefined,
+    };
+    const pan = createPanRecognizer(finalConfig.direction, finalConfig.threshold, finalConfig.maxAngle);
+    const gesture = GESTURE_CONTROLLER.createGesture({
+        name: config.gestureName,
+        priority: config.gesturePriority,
+        disableScroll: config.disableScroll,
+    });
+    const pointerDown = (ev) => {
+        const timeStamp = now(ev);
+        if (hasStartedPan || !hasFiredStart) {
+            return false;
+        }
+        updateDetail(ev, detail);
+        detail.startX = detail.currentX;
+        detail.startY = detail.currentY;
+        detail.startTime = detail.currentTime = timeStamp;
+        detail.velocityX = detail.velocityY = detail.deltaX = detail.deltaY = 0;
+        detail.event = ev;
+        // Check if gesture can start
+        if (canStart && canStart(detail) === false) {
+            return false;
+        }
+        // Release fallback
+        gesture.release();
+        // Start gesture
+        if (!gesture.start()) {
+            return false;
+        }
+        hasStartedPan = true;
+        if (threshold === 0) {
+            return tryToCapturePan();
+        }
+        pan.start(detail.startX, detail.startY);
+        return true;
+    };
+    const pointerMove = (ev) => {
+        // fast path, if gesture is currently captured
+        // do minimum job to get user-land even dispatched
+        if (hasCapturedPan) {
+            if (!isMoveQueued && hasFiredStart) {
+                isMoveQueued = true;
+                calcGestureData(detail, ev);
+                requestAnimationFrame(fireOnMove);
+            }
+            return;
+        }
+        // gesture is currently being detected
+        calcGestureData(detail, ev);
+        if (pan.detect(detail.currentX, detail.currentY)) {
+            if (!pan.isGesture() || !tryToCapturePan()) {
+                abortGesture();
+            }
+        }
+    };
+    const fireOnMove = () => {
+        // Since fireOnMove is called inside a RAF, onEnd() might be called,
+        // we must double check hasCapturedPan
+        if (!hasCapturedPan) {
+            return;
+        }
+        isMoveQueued = false;
+        if (onMove) {
+            onMove(detail);
+        }
+    };
+    const tryToCapturePan = () => {
+        if (!gesture.capture()) {
+            return false;
+        }
+        hasCapturedPan = true;
+        hasFiredStart = false;
+        // reset start position since the real user-land event starts here
+        // If the pan detector threshold is big, not resetting the start position
+        // will cause a jump in the animation equal to the detector threshold.
+        // the array of positions used to calculate the gesture velocity does not
+        // need to be cleaned, more points in the positions array always results in a
+        // more accurate value of the velocity.
+        detail.startX = detail.currentX;
+        detail.startY = detail.currentY;
+        detail.startTime = detail.currentTime;
+        if (onWillStart) {
+            onWillStart(detail).then(fireOnStart);
+        }
+        else {
+            fireOnStart();
+        }
+        return true;
+    };
+    const blurActiveElement = () => {
+        if (typeof document !== 'undefined') {
+            const activeElement = document.activeElement;
+            if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.blur) {
+                activeElement.blur();
+            }
+        }
+    };
+    const fireOnStart = () => {
+        if (blurOnStart) {
+            blurActiveElement();
+        }
+        if (onStart) {
+            onStart(detail);
+        }
+        hasFiredStart = true;
+    };
+    const reset = () => {
+        hasCapturedPan = false;
+        hasStartedPan = false;
+        isMoveQueued = false;
+        hasFiredStart = true;
+        gesture.release();
+    };
+    // END *************************
+    const pointerUp = (ev) => {
+        const tmpHasCaptured = hasCapturedPan;
+        const tmpHasFiredStart = hasFiredStart;
+        reset();
+        if (!tmpHasFiredStart) {
+            return;
+        }
+        calcGestureData(detail, ev);
+        // Try to capture press
+        if (tmpHasCaptured) {
+            if (onEnd) {
+                onEnd(detail);
+            }
+            return;
+        }
+        // Not captured any event
+        if (notCaptured) {
+            notCaptured(detail);
+        }
+    };
+    const pointerEvents = createPointerEvents(finalConfig.el, pointerDown, pointerMove, pointerUp, {
+        passive,
+    });
+    const abortGesture = () => {
+        reset();
+        pointerEvents.stop();
+        if (notCaptured) {
+            notCaptured(detail);
+        }
+    };
+    return {
+        enable(enable = true) {
+            if (!enable) {
+                if (hasCapturedPan) {
+                    pointerUp(undefined);
+                }
+                reset();
+            }
+            pointerEvents.enable(enable);
+        },
+        destroy() {
+            gesture.destroy();
+            pointerEvents.destroy();
+        },
+    };
+};
+const calcGestureData = (detail, ev) => {
+    if (!ev) {
+        return;
+    }
+    const prevX = detail.currentX;
+    const prevY = detail.currentY;
+    const prevT = detail.currentTime;
+    updateDetail(ev, detail);
+    const currentX = detail.currentX;
+    const currentY = detail.currentY;
+    const timestamp = (detail.currentTime = now(ev));
+    const timeDelta = timestamp - prevT;
+    if (timeDelta > 0 && timeDelta < 100) {
+        const velocityX = (currentX - prevX) / timeDelta;
+        const velocityY = (currentY - prevY) / timeDelta;
+        detail.velocityX = velocityX * 0.7 + detail.velocityX * 0.3;
+        detail.velocityY = velocityY * 0.7 + detail.velocityY * 0.3;
+    }
+    detail.deltaX = currentX - detail.startX;
+    detail.deltaY = currentY - detail.startY;
+    detail.event = ev;
+};
+const updateDetail = (ev, detail) => {
+    // get X coordinates for either a mouse click
+    // or a touch depending on the given event
+    let x = 0;
+    let y = 0;
+    if (ev) {
+        const changedTouches = ev.changedTouches;
+        if (changedTouches && changedTouches.length > 0) {
+            const touch = changedTouches[0];
+            x = touch.clientX;
+            y = touch.clientY;
+        }
+        else if (ev.pageX !== undefined) {
+            x = ev.pageX;
+            y = ev.pageY;
+        }
+    }
+    detail.currentX = x;
+    detail.currentY = y;
+};
+const now = (ev) => {
+    return ev.timeStamp || Date.now();
+};
+
+export { GESTURE_CONTROLLER, createGesture };

package/components/index4.js

@@ -1,4 +1,121 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-class t{constructor(){this.m=new Map}reset(t){this.m=new Map(Object.entries(t))}get(t,e){const n=this.m.get(t);return void 0!==n?n:e}getBoolean(t,e=!1){const n=this.m.get(t);return void 0===n?e:"string"==typeof n?"true"===n:!!n}getNumber(t,e){const n=parseFloat(this.m.get(t));return isNaN(n)?void 0!==e?e:NaN:n}set(t,e){this.m.set(t,e)}}const e=new t,n=t=>{try{const e=t.sessionStorage.getItem(i);return null!==e?JSON.parse(e):{}}catch(t){return{}}},o=(t,e)=>{try{t.sessionStorage.setItem(i,JSON.stringify(e))}catch(t){return}},r=t=>{const e={};return t.location.search.slice(1).split("&").map((t=>t.split("="))).map((([t,e])=>{try{return[decodeURIComponent(t),decodeURIComponent(e)]}catch(t){return["",""]}})).filter((([t])=>s(t,c))).map((([t,e])=>[t.slice(c.length),e])).forEach((([t,n])=>{e[t]=n})),e},s=(t,e)=>t.substr(0,e.length)===e,c="ionic:",i="ionic-persist-config";var a;!function(t){t.OFF="OFF",t.ERROR="ERROR",t.WARN="WARN"}(a||(a={}));const u=(t,...n)=>{const o=e.get("logLevel",a.WARN);if([a.WARN].includes(o))return console.warn(`[Ionic Warning]: ${t}`,...n)},l=(t,...n)=>{const o=e.get("logLevel",a.ERROR);if([a.ERROR,a.WARN].includes(o))return console.error(`[Ionic Error]: ${t}`,...n)},d=(t,...e)=>console.error(`<${t.tagName.toLowerCase()}> must be used inside ${e.join(" or ")}.`);export{a as L,l as a,n as b,e as c,r as d,d as e,u as p,o as s}
+// TODO(FW-2832): types
+class Config {
+    constructor() {
+        this.m = new Map();
+    }
+    reset(configObj) {
+        this.m = new Map(Object.entries(configObj));
+    }
+    get(key, fallback) {
+        const value = this.m.get(key);
+        return value !== undefined ? value : fallback;
+    }
+    getBoolean(key, fallback = false) {
+        const val = this.m.get(key);
+        if (val === undefined) {
+            return fallback;
+        }
+        if (typeof val === 'string') {
+            return val === 'true';
+        }
+        return !!val;
+    }
+    getNumber(key, fallback) {
+        const val = parseFloat(this.m.get(key));
+        return isNaN(val) ? (fallback !== undefined ? fallback : NaN) : val;
+    }
+    set(key, value) {
+        this.m.set(key, value);
+    }
+}
+const config = /*@__PURE__*/ new Config();
+const configFromSession = (win) => {
+    try {
+        const configStr = win.sessionStorage.getItem(IONIC_SESSION_KEY);
+        return configStr !== null ? JSON.parse(configStr) : {};
+    }
+    catch (e) {
+        return {};
+    }
+};
+const saveConfig = (win, c) => {
+    try {
+        win.sessionStorage.setItem(IONIC_SESSION_KEY, JSON.stringify(c));
+    }
+    catch (e) {
+        return;
+    }
+};
+const configFromURL = (win) => {
+    const configObj = {};
+    win.location.search
+        .slice(1)
+        .split('&')
+        .map((entry) => entry.split('='))
+        .map(([key, value]) => {
+        try {
+            return [decodeURIComponent(key), decodeURIComponent(value)];
+        }
+        catch (e) {
+            return ['', ''];
+        }
+    })
+        .filter(([key]) => startsWith(key, IONIC_PREFIX))
+        .map(([key, value]) => [key.slice(IONIC_PREFIX.length), value])
+        .forEach(([key, value]) => {
+        configObj[key] = value;
+    });
+    return configObj;
+};
+const startsWith = (input, search) => {
+    return input.substr(0, search.length) === search;
+};
+const IONIC_PREFIX = 'ionic:';
+const IONIC_SESSION_KEY = 'ionic-persist-config';
+
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["OFF"] = "OFF";
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["WARN"] = "WARN";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Logs a warning to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ */
+const printIonWarning = (message, ...params) => {
+    const logLevel = config.get('logLevel', LogLevel.WARN);
+    if ([LogLevel.WARN].includes(logLevel)) {
+        return console.warn(`[Ionic Warning]: ${message}`, ...params);
+    }
+};
+/**
+ * Logs an error to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ * @param params - Additional arguments to supply to the console.error.
+ */
+const printIonError = (message, ...params) => {
+    const logLevel = config.get('logLevel', LogLevel.ERROR);
+    if ([LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) {
+        return console.error(`[Ionic Error]: ${message}`, ...params);
+    }
+};
+/**
+ * Prints an error informing developers that an implementation requires an element to be used
+ * within a specific selector.
+ *
+ * @param el The web component element this is requiring the element.
+ * @param targetSelectors The selector or selectors that were not found.
+ */
+const printRequiredElementError = (el, ...targetSelectors) => {
+    return console.error(`<${el.tagName.toLowerCase()}> must be used inside ${targetSelectors.join(' or ')}.`);
+};
+
+export { LogLevel as L, printIonError as a, configFromSession as b, config as c, configFromURL as d, printRequiredElementError as e, printIonWarning as p, saveConfig as s };