diff --git a/core/pom.xml b/core/pom.xml index d3433b861..0f81be222 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -47,6 +47,9 @@ **/META-INF/resources/**/codemirror/lib/** **/META-INF/resources/**/codemirror/theme/** **/META-INF/resources/**/codemirror/LICENSE + **/META-INF/resources/**/keynote/lib/** + **/META-INF/resources/**/keynote/plugin/** + **/META-INF/resources/**/keynote/LICENSE **/META-INF/resources/**/dynaform/** **/META-INF/resources/**/masterdetail/** **/META-INF/resources/**/imagerotateandresize/** @@ -192,6 +195,32 @@ + + + keynote/lib/reveal.js + keynote/plugin/markdown/markdown.js + keynote/widget.js + + + + ${resources.dir.compressed} + ${resources.dir.compressed}/keynote/keynote.js + ${withoutCompress} + + + + + + keynote/lib/**/*.css + + + + ${resources.dir.compressed} + ${resources.dir.compressed}/keynote/keynote.css + ${withoutCompress} + + + codescanner/zxing.min.js diff --git a/core/src/main/java/org/primefaces/extensions/component/keynote/Keynote.java b/core/src/main/java/org/primefaces/extensions/component/keynote/Keynote.java new file mode 100644 index 000000000..a7898ec01 --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/component/keynote/Keynote.java @@ -0,0 +1,613 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.component.keynote; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import javax.faces.FacesException; +import javax.faces.application.ResourceDependency; +import javax.faces.component.ContextCallback; +import javax.faces.component.UIComponent; +import javax.faces.component.UINamingContainer; +import javax.faces.component.behavior.ClientBehaviorHolder; +import javax.faces.component.visit.VisitCallback; +import javax.faces.component.visit.VisitContext; +import javax.faces.context.FacesContext; +import javax.faces.event.AjaxBehaviorEvent; +import javax.faces.event.BehaviorEvent; +import javax.faces.event.FacesEvent; +import javax.faces.event.PhaseId; + +import org.primefaces.component.api.PrimeClientBehaviorHolder; +import org.primefaces.component.api.Widget; +import org.primefaces.extensions.component.base.AbstractDynamicData; +import org.primefaces.extensions.event.KeynoteEvent; +import org.primefaces.extensions.model.common.KeyData; +import org.primefaces.extensions.model.keynote.KeynoteItem; +import org.primefaces.util.Constants; +import org.primefaces.util.MapBuilder; + +@ResourceDependency(library = "primefaces", name = "jquery/jquery.js") +@ResourceDependency(library = "primefaces", name = "jquery/jquery-plugins.js") +@ResourceDependency(library = "primefaces", name = "core.js") +@ResourceDependency(library = "primefaces-extensions", name = "primefaces-extensions.js") +@ResourceDependency(library = "primefaces-extensions", name = "keynote/keynote.js") +@ResourceDependency(library = "primefaces-extensions", name = "keynote/keynote.css") +public class Keynote extends AbstractDynamicData implements Widget, ClientBehaviorHolder, PrimeClientBehaviorHolder { + + public static final String COMPONENT_TYPE = "org.primefaces.extensions.component.Keynote"; + public static final String COMPONENT_FAMILY = "org.primefaces.extensions.component"; + public static final String DEFAULT_RENDERER = "org.primefaces.extensions.component.KeynoteRenderer"; + + private static final String DEFAULT_EVENT = "slideChanged"; + + private static final Map> BEHAVIOR_EVENT_MAPPING = MapBuilder.> builder() + .put("slideTransitionEnd", null) + .put(DEFAULT_EVENT, null) + .build(); + + private static final Collection EVENT_NAMES = BEHAVIOR_EVENT_MAPPING.keySet(); + + private Map items; + + protected enum PropertyKeys { + //@formatter:off + widgetVar, + width, + height, + margin, + minScale, + maxScale, + autoSlide, + center, + controls, + disableLayout, + embedded, + loop, + navigationMode, + progress, + showNotes, + slideNumber, + touch, + transition, + transitionSpeed, + backgroundTransition, + theme, + library, + style, + styleClass + //@formatter:on + } + + public Keynote() { + setRendererType(DEFAULT_RENDERER); + } + + @Override + public Map> getBehaviorEventMapping() { + return BEHAVIOR_EVENT_MAPPING; + } + + @Override + public Collection getEventNames() { + return EVENT_NAMES; + } + + @Override + public String getDefaultEventName() { + return DEFAULT_EVENT; + } + + @Override + public String getFamily() { + return COMPONENT_FAMILY; + } + + public int getWidth() { + return (Integer) getStateHelper().eval(PropertyKeys.width, 960); + } + + public void setWidth(final int width) { + getStateHelper().put(PropertyKeys.width, width); + } + + public int getHeight() { + return (Integer) getStateHelper().eval(PropertyKeys.height, 700); + } + + public void setHeight(final int height) { + getStateHelper().put(PropertyKeys.height, height); + } + + public Double getMargin() { + return (Double) getStateHelper().eval(PropertyKeys.margin, 0.04); + } + + public void setMargin(final Double margin) { + getStateHelper().put(PropertyKeys.margin, margin); + } + + public Double getMinScale() { + return (Double) getStateHelper().eval(PropertyKeys.minScale, 0.2); + } + + public void setMinScale(final Double minScale) { + getStateHelper().put(PropertyKeys.minScale, minScale); + } + + public Double getMaxScale() { + return (Double) getStateHelper().eval(PropertyKeys.maxScale, 2.0); + } + + public void setMaxScale(final Double maxScale) { + getStateHelper().put(PropertyKeys.maxScale, maxScale); + } + + public int getAutoSlide() { + return (Integer) getStateHelper().eval(PropertyKeys.autoSlide, 0); + } + + public void setAutoSlide(final int autoSlide) { + getStateHelper().put(PropertyKeys.autoSlide, autoSlide); + } + + public Boolean isCenter() { + return (Boolean) getStateHelper().eval(PropertyKeys.center, true); + } + + public void setCenter(final Boolean center) { + getStateHelper().put(PropertyKeys.center, center); + } + + public Boolean isControls() { + return (Boolean) getStateHelper().eval(PropertyKeys.controls, true); + } + + public void setControls(final Boolean controls) { + getStateHelper().put(PropertyKeys.controls, controls); + } + + public Boolean isDisableLayout() { + return (Boolean) getStateHelper().eval(PropertyKeys.disableLayout, false); + } + + public void setDisableLayout(final Boolean disableLayout) { + getStateHelper().put(PropertyKeys.disableLayout, disableLayout); + } + + public Boolean isEmbedded() { + return (Boolean) getStateHelper().eval(PropertyKeys.embedded, false); + } + + public void setEmbedded(final Boolean embedded) { + getStateHelper().put(PropertyKeys.embedded, embedded); + } + + public Boolean isLoop() { + return (Boolean) getStateHelper().eval(PropertyKeys.loop, false); + } + + public void setLoop(final Boolean loop) { + getStateHelper().put(PropertyKeys.loop, loop); + } + + public String getNavigationMode() { + return (String) getStateHelper().eval(PropertyKeys.navigationMode, "default"); + } + + public void setNavigationMode(final String navigationMode) { + getStateHelper().put(PropertyKeys.navigationMode, navigationMode); + } + + public Boolean isProgress() { + return (Boolean) getStateHelper().eval(PropertyKeys.progress, true); + } + + public void setProgress(final Boolean progress) { + getStateHelper().put(PropertyKeys.progress, progress); + } + + public Boolean isShowNotes() { + return (Boolean) getStateHelper().eval(PropertyKeys.showNotes, false); + } + + public void setShowNotes(final Boolean showNotes) { + getStateHelper().put(PropertyKeys.showNotes, showNotes); + } + + public String getSlideNumber() { + return (String) getStateHelper().eval(PropertyKeys.slideNumber, "false"); + } + + public void setSlideNumber(final String slideNumber) { + getStateHelper().put(PropertyKeys.slideNumber, slideNumber); + } + + public Boolean isTouch() { + return (Boolean) getStateHelper().eval(PropertyKeys.touch, true); + } + + public void setTouch(final Boolean touch) { + getStateHelper().put(PropertyKeys.touch, touch); + } + + public String getTransition() { + return (String) getStateHelper().eval(PropertyKeys.transition, "slide"); + } + + public void setTransition(final String transition) { + getStateHelper().put(PropertyKeys.transition, transition); + } + + public String getTransitionSpeed() { + return (String) getStateHelper().eval(PropertyKeys.transitionSpeed, "default"); + } + + public void setTransitionSpeed(final String transitionSpeed) { + getStateHelper().put(PropertyKeys.transitionSpeed, transitionSpeed); + } + + public String getBackgroundTransition() { + return (String) getStateHelper().eval(PropertyKeys.backgroundTransition, "fade"); + } + + public void setBackgroundTransition(final String backgroundTransition) { + getStateHelper().put(PropertyKeys.backgroundTransition, backgroundTransition); + } + + public String getTheme() { + return (String) getStateHelper().eval(PropertyKeys.theme, "none"); + } + + public void setTheme(final String theme) { + getStateHelper().put(PropertyKeys.theme, theme); + } + + public String getLibrary() { + return (String) getStateHelper().eval(PropertyKeys.library, org.primefaces.extensions.util.Constants.LIBRARY); + } + + public void setLibrary(final String library) { + getStateHelper().put(PropertyKeys.library, library); + } + + public String getWidgetVar() { + return (String) getStateHelper().eval(PropertyKeys.widgetVar, null); + } + + public void setWidgetVar(final String widgetVar) { + getStateHelper().put(PropertyKeys.widgetVar, widgetVar); + } + + public String getStyle() { + return (String) getStateHelper().eval(PropertyKeys.style, null); + } + + public void setStyle(String style) { + getStateHelper().put(PropertyKeys.style, style); + } + + public String getStyleClass() { + return (String) getStateHelper().eval(PropertyKeys.styleClass, null); + } + + public void setStyleClass(String styleClass) { + getStateHelper().put(PropertyKeys.styleClass, styleClass); + } + + @Override + public void queueEvent(final FacesEvent event) { + if (event instanceof AjaxBehaviorEvent) { + final FacesContext context = getFacesContext(); + final AjaxBehaviorEvent behaviorEvent = (AjaxBehaviorEvent) event; + final Map params = context.getExternalContext().getRequestParameterMap(); + final String eventName = params.get(Constants.RequestParams.PARTIAL_BEHAVIOR_EVENT_PARAM); + + if ("slideTransitionEnd".equals(eventName)) { + final Boolean slideTransitionEnd = Boolean.parseBoolean(params.get(getClientId(context) + "_slideTransitionEnd")); + final Boolean lastSlide = Boolean.parseBoolean(params.get(getClientId(context) + "_lastSlide")); + final KeynoteEvent keynoteEvent = new KeynoteEvent(this, behaviorEvent.getBehavior(), slideTransitionEnd, lastSlide); + keynoteEvent.setPhaseId(event.getPhaseId()); + super.queueEvent(keynoteEvent); + } + else if (DEFAULT_EVENT.equals(eventName)) { + final Boolean slideChanged = Boolean.parseBoolean(params.get(getClientId(context) + "_slideChanged")); + final Boolean lastSlide = Boolean.parseBoolean(params.get(getClientId(context) + "_lastSlide")); + final KeynoteEvent keynoteEvent = new KeynoteEvent(this, behaviorEvent.getBehavior(), slideChanged, lastSlide); + keynoteEvent.setPhaseId(event.getPhaseId()); + super.queueEvent(keynoteEvent); + } + else { + super.queueEvent(event); + } + } + else { + super.queueEvent(event); + } + } + + public UIKeynoteItem getItem(final String type) { + final UIKeynoteItem item = getItems().get(type); + + if (item == null) { + throw new FacesException("UIKeynoteItem to type " + type + " was not found"); + } + else { + return item; + } + } + + protected Map getItems() { + if (items == null) { + items = new HashMap<>(); + for (final UIComponent child : getChildren()) { + if (child instanceof UIKeynoteItem) { + final UIKeynoteItem keynoteItem = (UIKeynoteItem) child; + items.put(keynoteItem.getType(), keynoteItem); + } + } + } + + return items; + } + + protected static void checkModelInstance(Object value) { + if (!(value instanceof Collection)) { + throw new FacesException("Value in Keynote must be of type Collection / List"); + } + } + + @Override + protected KeyData findData(final String key) { + final Object value = getValue(); + if (value == null) { + return null; + } + + checkModelInstance(value); + + final Collection col = (Collection) value; + for (final KeynoteItem keynoteItem : col) { + if (key.equals(keynoteItem.getKey())) { + return keynoteItem; + } + } + + return null; + } + + @Override + protected void processChildren(final FacesContext context, final PhaseId phaseId) { + if (getVar() != null) { + // dynamic items + final Object value = getValue(); + if (value != null) { + checkModelInstance(value); + + final Collection col = (Collection) value; + for (final KeynoteItem keynoteItem : col) { + processKeynoteDynamicItems(context, phaseId, keynoteItem); + } + } + + resetData(); + } + else { + // static items + processKeynoteStaticItems(context, phaseId); + } + } + + @Override + protected boolean visitChildren(final VisitContext context, final VisitCallback callback) { + if (getVar() != null) { + // dynamic items + final Object value = getValue(); + if (value == null) { + return false; + } + + checkModelInstance(value); + + final Collection col = (Collection) value; + for (final KeynoteItem keynoteItem : col) { + if (visitKeynoteDynamicItems(context, callback, keynoteItem)) { + return true; + } + } + + resetData(); + } + else { + // static items + if (visitKeynoteStaticItems(context, callback)) { + return true; + } + } + + return false; + } + + @Override + protected boolean invokeOnChildren(final FacesContext context, final String clientId, final ContextCallback callback) { + + final Object value = getValue(); + if (value == null) { + return false; + } + + checkModelInstance(value); + + if (getChildCount() > 0) { + // extract the keynoteItem key from the clientId + // it's simliar to rowKey in UIData + String key = clientId.substring(getClientId().length() + 1); + key = key.substring(0, key.indexOf(UINamingContainer.getSeparatorChar(context))); + + final Collection keynoteItems = (Collection) value; + for (final KeynoteItem keynoteItem : keynoteItems) { + + // determine associated KeynoteItem + if (keynoteItem.getKey().equals(key)) { + + // get UI control for KeynoteItem + UIKeynoteItem uiKeynoteItem = null; + if (getVar() == null) { + for (final UIComponent child : getChildren()) { + if (child instanceof UIKeynoteItem && ((UIKeynoteItem) child).getType().equals(keynoteItem.getType())) { + uiKeynoteItem = (UIKeynoteItem) child; + } + } + } + else { + uiKeynoteItem = (UIKeynoteItem) getChildren().get(0); + } + + if (uiKeynoteItem == null) { + continue; + } + + try { + // push the associated data before visiting the child components + setData(keynoteItem); + + // visit childs + if (uiKeynoteItem.invokeOnComponent(context, clientId, callback)) { + return true; + } + } + finally { + resetData(); + } + + } + } + } + + return false; + } + + private void processKeynoteDynamicItems(final FacesContext context, final PhaseId phaseId, + final KeynoteItem keynoteItem) { + for (final UIComponent kid : getChildren()) { + if (!(kid instanceof UIKeynoteItem) || !kid.isRendered() + || !((UIKeynoteItem) kid).getType().equals(keynoteItem.getType())) { + continue; + } + + for (final UIComponent grandkid : kid.getChildren()) { + if (!grandkid.isRendered()) { + continue; + } + + setData(keynoteItem); + if (getData() == null) { + return; + } + + if (phaseId == PhaseId.APPLY_REQUEST_VALUES) { + grandkid.processDecodes(context); + } + else if (phaseId == PhaseId.PROCESS_VALIDATIONS) { + grandkid.processValidators(context); + } + else if (phaseId == PhaseId.UPDATE_MODEL_VALUES) { + grandkid.processUpdates(context); + } + else { + throw new IllegalArgumentException(); + } + } + } + } + + private void processKeynoteStaticItems(final FacesContext context, final PhaseId phaseId) { + for (final UIComponent kid : getChildren()) { + if (!(kid instanceof UIKeynoteItem) || !kid.isRendered()) { + continue; + } + + for (final UIComponent grandkid : kid.getChildren()) { + if (!grandkid.isRendered()) { + continue; + } + + if (phaseId == PhaseId.APPLY_REQUEST_VALUES) { + grandkid.processDecodes(context); + } + else if (phaseId == PhaseId.PROCESS_VALIDATIONS) { + grandkid.processValidators(context); + } + else if (phaseId == PhaseId.UPDATE_MODEL_VALUES) { + grandkid.processUpdates(context); + } + else { + throw new IllegalArgumentException(); + } + } + } + } + + private boolean visitKeynoteDynamicItems(final VisitContext context, final VisitCallback callback, + final KeynoteItem keynoteItem) { + if (getChildCount() > 0) { + for (final UIComponent child : getChildren()) { + if (child instanceof UIKeynoteItem + && ((UIKeynoteItem) child).getType().equals(keynoteItem.getType())) { + setData(keynoteItem); + if (getData() == null) { + return false; + } + + if (child.visitTree(context, callback)) { + return true; + } + } + } + } + + return false; + } + + private boolean visitKeynoteStaticItems(final VisitContext context, final VisitCallback callback) { + if (getChildCount() > 0) { + for (final UIComponent child : getChildren()) { + if (child instanceof UIKeynoteItem && child.visitTree(context, callback)) { + return true; + } + } + } + + return false; + } + + @Override + public Object saveState(final FacesContext context) { + // reset component for MyFaces view pooling + items = null; + + return super.saveState(context); + } + +} diff --git a/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteItemRenderer.java b/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteItemRenderer.java new file mode 100644 index 000000000..abb08c248 --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteItemRenderer.java @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.component.keynote; + +import java.io.IOException; + +import javax.faces.component.UIComponent; +import javax.faces.context.FacesContext; +import javax.faces.context.ResponseWriter; + +import org.primefaces.extensions.util.Attrs; +import org.primefaces.renderkit.CoreRenderer; + +public class KeynoteItemRenderer extends CoreRenderer { + + public static final String ITEM_CLASS = "ui-keynote-item"; + public static final String SPEAKER_NOTE_CLASS = "notes"; + + @Override + public void encodeEnd(final FacesContext context, final UIComponent component) throws IOException { + final ResponseWriter writer = context.getResponseWriter(); + final UIKeynoteItem uiKeynoteItem = (UIKeynoteItem) component; + + writer.startElement("section", null); + + if (uiKeynoteItem.isMarkdown()) { + writer.writeAttribute("data-markdown", "", null); + writer.writeAttribute("data-separator", uiKeynoteItem.getSeparator(), null); + writer.writeAttribute("data-separator-vertical", uiKeynoteItem.getSeparatorVertical(), null); + } + + if (uiKeynoteItem.getBackgroundColor() != null) { + writer.writeAttribute("data-background-color", uiKeynoteItem.getBackgroundColor(), null); + } + if (uiKeynoteItem.getBackgroundImage() != null) { + writer.writeAttribute("data-background-image", uiKeynoteItem.getBackgroundImage(), null); + } + if (uiKeynoteItem.getBackgroundSize() != null) { + writer.writeAttribute("data-background-size", uiKeynoteItem.getBackgroundSize(), null); + } + if (uiKeynoteItem.getBackgroundPosition() != null) { + writer.writeAttribute("data-background-position", uiKeynoteItem.getBackgroundPosition(), null); + } + if (uiKeynoteItem.getBackgroundRepeat() != null) { + writer.writeAttribute("data-background-repeat", uiKeynoteItem.getBackgroundRepeat(), null); + } + if (uiKeynoteItem.getBackgroundOpacity() != null) { + writer.writeAttribute("data-background-opacity", uiKeynoteItem.getBackgroundOpacity(), null); + } + if (uiKeynoteItem.getBackgroundVideo() != null) { + writer.writeAttribute("data-background-video", uiKeynoteItem.getBackgroundVideo(), null); + } + if (uiKeynoteItem.isBackgroundVideoLoop()) { + writer.writeAttribute("data-background-video-loop", "", null); + } + if (uiKeynoteItem.isBackgroundVideoMuted()) { + writer.writeAttribute("data-background-video-muted", "", null); + } + if (uiKeynoteItem.getVisibility() != null) { + writer.writeAttribute("data-visibility", uiKeynoteItem.getVisibility(), null); + } + + if (uiKeynoteItem.getStyleClass() != null) { + writer.writeAttribute(Attrs.CLASS, ITEM_CLASS + " " + uiKeynoteItem.getStyleClass(), null); + } + else { + writer.writeAttribute(Attrs.CLASS, ITEM_CLASS, null); + } + + if (uiKeynoteItem.isMarkdown()) { + writer.startElement("textarea", null); + writer.writeAttribute("data-template", "", null); + } + + // encode content + renderChildren(context, uiKeynoteItem); + + if (uiKeynoteItem.isMarkdown()) { + writer.endElement("textarea"); + } + + if (uiKeynoteItem.getNote() != null) { + writer.startElement("aside", null); + writer.writeAttribute(Attrs.CLASS, SPEAKER_NOTE_CLASS, null); + writer.writeText(uiKeynoteItem.getNote(), null); + writer.endElement("aside"); + } + + writer.endElement("section"); + } + + @Override + public boolean getRendersChildren() { + return true; + } + + @Override + public void encodeChildren(final FacesContext fc, final UIComponent component) { + // nothing to do + } +} diff --git a/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteRenderer.java b/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteRenderer.java new file mode 100644 index 000000000..cf8f857b3 --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/component/keynote/KeynoteRenderer.java @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.component.keynote; + +import java.io.IOException; +import java.util.Collection; +import java.util.List; + +import javax.faces.FacesException; +import javax.faces.application.Resource; +import javax.faces.component.UIComponent; +import javax.faces.context.ExternalContext; +import javax.faces.context.FacesContext; +import javax.faces.context.ResponseWriter; + +import org.primefaces.extensions.model.keynote.KeynoteItem; +import org.primefaces.extensions.util.Attrs; +import org.primefaces.renderkit.CoreRenderer; +import org.primefaces.util.WidgetBuilder; + +public class KeynoteRenderer extends CoreRenderer { + + public static final String CONTAINER_CLASS = "ui-keynote reveal"; + public static final String SLIDES_CLASS = "slides"; + + /** + * {@inheritDoc} + */ + @Override + public void decode(final FacesContext context, final UIComponent component) { + decodeBehaviors(context, component); + } + + /** + * {@inheritDoc} + */ + @Override + public void encodeBegin(FacesContext context, UIComponent component) throws IOException { + final Keynote keynote = (Keynote) component; + + if (!"none".equals(keynote.getTheme())) { + encodeCSS(context, keynote.getLibrary(), keynote.getTheme()); + } + } + + /** + * {@inheritDoc} + */ + @Override + public void encodeEnd(final FacesContext context, final UIComponent component) throws IOException { + final Keynote keynote = (Keynote) component; + + encodeMarkup(context, keynote); + encodeScript(context, keynote); + } + + /** + * Create the HTML markup for the DOM. + */ + private void encodeMarkup(final FacesContext context, final Keynote keynote) throws IOException { + final ResponseWriter writer = context.getResponseWriter(); + final String clientId = keynote.getClientId(context); + final String styleClass = getStyleClassBuilder(context) + .add(CONTAINER_CLASS) + .add(keynote.getStyleClass()) + .build(); + + writer.startElement("div", keynote); + writer.writeAttribute("id", clientId, null); + writer.writeAttribute(Attrs.CLASS, styleClass, "styleClass"); + if (keynote.getStyle() != null) { + writer.writeAttribute(Attrs.STYLE, keynote.getStyle(), Attrs.STYLE); + } + + writer.startElement("div", null); + writer.writeAttribute(Attrs.CLASS, SLIDES_CLASS, "class"); + + if (keynote.getVar() != null) { + // dynamic items + final Object value = keynote.getValue(); + if (value != null) { + if (!(value instanceof Collection)) { + throw new FacesException("Value in Keynote must be of type Collection / List"); + } + + List children = keynote.getChildren(); + for (int i = 0; i < children.size(); i++) { + final UIComponent kid = children.get(i); + if (kid.isRendered() && !(kid instanceof UIKeynoteItem)) { + // first render children like stamped elements, etc. + renderChild(context, kid); + } + } + + final Collection col = (Collection) value; + for (int i = 0; i < col.size(); i++) { + final KeynoteItem keynoteItem = (KeynoteItem) col.toArray()[i]; + // find ui item by type + final UIKeynoteItem uiItem = keynote.getItem(keynoteItem.getType()); + + if (uiItem.isRendered()) { + // set data in request scope + keynote.setData(keynoteItem); + + // render item + renderChild(context, uiItem); + } + } + } + } + else { + // static items + List children = keynote.getChildren(); + for (int i = 0; i < children.size(); i++) { + final UIComponent kid = children.get(i); + if (kid.isRendered()) { + renderChild(context, kid); + } + } + } + + writer.endElement("div"); + + writer.endElement("div"); + } + + /** + * Create the Javascript. + */ + private void encodeScript(final FacesContext context, final Keynote keynote) throws IOException { + final WidgetBuilder wb = getWidgetBuilder(context); + + wb.init("ExtKeynote", keynote) + .attr("width", keynote.getWidth(), 960) + .attr("height", keynote.getHeight(), 700) + .attr("margin", keynote.getMargin(), 0.04) + .attr("minScale", keynote.getMinScale(), 0.2) + .attr("maxScale", keynote.getMaxScale(), 2.0) + .attr("autoSlide", keynote.getAutoSlide(), 0) + .attr("center", keynote.isCenter(), true) + .attr("controls", keynote.isControls(), true) + .attr("disableLayout", keynote.isDisableLayout(), false) + .attr("embedded", keynote.isEmbedded(), false) + .attr("loop", keynote.isLoop(), false) + .attr("navigationMode", keynote.getNavigationMode(), "default") + .attr("progress", keynote.isProgress(), true) + .attr("showNotes", keynote.isShowNotes(), false) + .attr("slideNumber", keynote.getSlideNumber(), "false") + .attr("touch", keynote.isTouch(), true) + .attr("transition", keynote.getTransition(), "slide") + .attr("transitionSpeed", keynote.getTransitionSpeed(), "default") + .attr("backgroundTransition", keynote.getBackgroundTransition(), "fade") + .attr("theme", keynote.getTheme(), "none"); + + encodeClientBehaviors(context, keynote); + + wb.finish(); + } + + private void encodeCSS(FacesContext context, String library, String theme) throws IOException { + final ResponseWriter writer = context.getResponseWriter(); + ExternalContext externalContext = context.getExternalContext(); + + Resource cssResource = context.getApplication() + .getResourceHandler() + .createResource("keynote/theme/" + theme + ".css", library); + if (cssResource == null) { + throw new FacesException("Error loading CSS, cannot find \"" + theme + "\" resource of \"" + library + "\" library"); + } + else { + writer.startElement("link", null); + writer.writeAttribute("type", "text/css", null); + writer.writeAttribute("rel", "stylesheet", null); + writer.writeAttribute("href", externalContext.encodeResourceURL(cssResource.getRequestPath()), null); + writer.endElement("link"); + } + } + + /** + * {@inheritDoc} + */ + @Override + public void encodeChildren(final FacesContext context, final UIComponent component) { + // Do nothing + } + + /** + * {@inheritDoc} + */ + @Override + public boolean getRendersChildren() { + return true; + } + +} diff --git a/core/src/main/java/org/primefaces/extensions/component/keynote/UIKeynoteItem.java b/core/src/main/java/org/primefaces/extensions/component/keynote/UIKeynoteItem.java new file mode 100644 index 000000000..2bab3a98d --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/component/keynote/UIKeynoteItem.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.component.keynote; + +import javax.faces.component.UIComponentBase; + +import org.primefaces.extensions.model.keynote.KeynoteItem; + +public class UIKeynoteItem extends UIComponentBase { + + public static final String COMPONENT_TYPE = "org.primefaces.extensions.component.UIKeynoteItem"; + public static final String COMPONENT_FAMILY = "org.primefaces.extensions.component"; + private static final String DEFAULT_RENDERER = "org.primefaces.extensions.component.KeynoteItemRenderer"; + + protected enum PropertyKeys { + // @formatter:off + backgroundColor, + backgroundImage, + backgroundSize, + backgroundPosition, + backgroundRepeat, + backgroundOpacity, + backgroundVideo, + backgroundVideoLoop, + backgroundVideoMuted, + markdown, + note, + separator, + separatorVertical, + styleClass, + type, + visibility, + // @formatter:on + } + + public UIKeynoteItem() { + setRendererType(null); + } + + @Override + public String getFamily() { + return COMPONENT_FAMILY; + } + + public String getBackgroundColor() { + return (String) getStateHelper().eval(PropertyKeys.backgroundColor, null); + } + + public void setBackgroundColor(final String backgroundColor) { + getStateHelper().put(PropertyKeys.backgroundColor, backgroundColor); + } + + public String getBackgroundImage() { + return (String) getStateHelper().eval(PropertyKeys.backgroundImage, null); + } + + public void setBackgroundImage(final String backgroundImage) { + getStateHelper().put(PropertyKeys.backgroundImage, backgroundImage); + } + + public String getBackgroundSize() { + return (String) getStateHelper().eval(PropertyKeys.backgroundSize, "cover"); + } + + public void setBackgroundSize(final String backgroundSize) { + getStateHelper().put(PropertyKeys.backgroundSize, backgroundSize); + } + + public String getBackgroundPosition() { + return (String) getStateHelper().eval(PropertyKeys.backgroundPosition, "center"); + } + + public void setBackgroundPosition(final String backgroundPosition) { + getStateHelper().put(PropertyKeys.backgroundPosition, backgroundPosition); + } + + public String getBackgroundRepeat() { + return (String) getStateHelper().eval(PropertyKeys.backgroundRepeat, "no-repeat"); + } + + public void setBackgroundRepeat(final String backgroundRepeat) { + getStateHelper().put(PropertyKeys.backgroundRepeat, backgroundRepeat); + } + + public Double getBackgroundOpacity() { + return (Double) getStateHelper().eval(PropertyKeys.backgroundOpacity, 1.0); + } + + public void setBackgroundOpacity(final Double backgroundOpacity) { + getStateHelper().put(PropertyKeys.backgroundOpacity, backgroundOpacity); + } + + public String getBackgroundVideo() { + return (String) getStateHelper().eval(PropertyKeys.backgroundVideo, null); + } + + public void setBackgroundVideo(final String backgroundVideo) { + getStateHelper().put(PropertyKeys.backgroundVideo, backgroundVideo); + } + + public Boolean isBackgroundVideoLoop() { + return (Boolean) getStateHelper().eval(PropertyKeys.backgroundVideoLoop, false); + } + + public void setBackgroundVideoLoop(final Boolean backgroundVideoLoop) { + getStateHelper().put(PropertyKeys.backgroundVideoLoop, backgroundVideoLoop); + } + + public Boolean isBackgroundVideoMuted() { + return (Boolean) getStateHelper().eval(PropertyKeys.backgroundVideoMuted, false); + } + + public void setBackgroundVideoMuted(final Boolean backgroundVideoMuted) { + getStateHelper().put(PropertyKeys.backgroundVideoMuted, backgroundVideoMuted); + } + + public Boolean isMarkdown() { + return (Boolean) getStateHelper().eval(PropertyKeys.markdown, false); + } + + public void setMarkdown(final Boolean markdown) { + getStateHelper().put(PropertyKeys.markdown, markdown); + } + + public String getNote() { + return (String) getStateHelper().eval(PropertyKeys.note, null); + } + + public void setNote(final String note) { + getStateHelper().put(PropertyKeys.note, note); + } + + public String getSeparator() { + return (String) getStateHelper().eval(PropertyKeys.separator, "^---$"); + } + + public void setSeparator(final String separator) { + getStateHelper().put(PropertyKeys.separator, separator); + } + + public String getSeparatorVertical() { + return (String) getStateHelper().eval(PropertyKeys.separatorVertical, null); + } + + public void setSeparatorVertical(final String separatorVertical) { + getStateHelper().put(PropertyKeys.separatorVertical, separatorVertical); + } + + public String getStyleClass() { + return (String) getStateHelper().eval(PropertyKeys.styleClass, null); + } + + public void setStyleClass(final String styleClass) { + getStateHelper().put(PropertyKeys.styleClass, styleClass); + } + + public String getType() { + return (String) getStateHelper().eval(PropertyKeys.type, KeynoteItem.DEFAULT_TYPE); + } + + public void setType(final String type) { + getStateHelper().put(PropertyKeys.type, type); + } + + public String getVisibility() { + return (String) getStateHelper().eval(PropertyKeys.visibility, null); + } + + public void setVisibility(final String visibility) { + getStateHelper().put(PropertyKeys.visibility, visibility); + } +} diff --git a/core/src/main/java/org/primefaces/extensions/event/KeynoteEvent.java b/core/src/main/java/org/primefaces/extensions/event/KeynoteEvent.java new file mode 100644 index 000000000..585b15506 --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/event/KeynoteEvent.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.event; + +import javax.faces.component.UIComponent; +import javax.faces.component.behavior.Behavior; + +import org.primefaces.event.AbstractAjaxBehaviorEvent; + +public class KeynoteEvent extends AbstractAjaxBehaviorEvent { + + private static final long serialVersionUID = 1L; + + private final boolean completed; + private final boolean lastSlide; + + public KeynoteEvent(final UIComponent component, final Behavior behavior, final boolean completed, final boolean lastSlide) { + super(component, behavior); + this.completed = completed; + this.lastSlide = lastSlide; + } + + public boolean isCompleted() { + return completed; + } + + public boolean isLastSlide() { + return lastSlide; + } + +} diff --git a/core/src/main/java/org/primefaces/extensions/model/keynote/KeynoteItem.java b/core/src/main/java/org/primefaces/extensions/model/keynote/KeynoteItem.java new file mode 100644 index 000000000..c7085c48f --- /dev/null +++ b/core/src/main/java/org/primefaces/extensions/model/keynote/KeynoteItem.java @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2011-2021 PrimeFaces Extensions + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package org.primefaces.extensions.model.keynote; + +import java.io.Serializable; +import java.util.Objects; +import java.util.UUID; + +import org.primefaces.extensions.model.common.KeyData; + +public class KeynoteItem implements KeyData, Serializable { + + public static final String DEFAULT_TYPE = "default"; + private static final long serialVersionUID = 1L; + + private String key; + private Serializable data; + private String type; + + public KeynoteItem() { + // generate key + setKey(generateKey()); + } + + public KeynoteItem(final Serializable data) { + this(); + this.data = data; + type = DEFAULT_TYPE; + } + + public KeynoteItem(final Serializable data, final String type) { + this.data = data; + if (type != null) { + this.type = type; + } + else { + this.type = DEFAULT_TYPE; + } + + // generate key + setKey(generateKey()); + } + + @Override + public String getKey() { + return key; + } + + @Override + public void setKey(final String key) { + this.key = key; + } + + @Override + public Serializable getData() { + return data; + } + + @Override + public void setData(final Serializable data) { + this.data = data; + } + + public String getType() { + return type; + } + + public static String generateKey() { + return UUID.randomUUID().toString().replace("-", "").substring(0, 8); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof KeynoteItem)) { + return false; + } + KeynoteItem that = (KeynoteItem) o; + return Objects.equals(getKey(), that.getKey()); + } + + @Override + public int hashCode() { + return Objects.hash(getKey()); + } + + @Override + public String toString() { + final StringBuilder builder = new StringBuilder(); + builder.append("KeynoteItem [key="); + builder.append(key); + builder.append(", data="); + builder.append(data); + builder.append(", type="); + builder.append(type); + builder.append("]"); + return builder.toString(); + } + +} diff --git a/core/src/main/resources/META-INF/NOTICE.txt b/core/src/main/resources/META-INF/NOTICE.txt index 078fc3050..7a587ef5f 100644 --- a/core/src/main/resources/META-INF/NOTICE.txt +++ b/core/src/main/resources/META-INF/NOTICE.txt @@ -27,3 +27,4 @@ This product includes software developed by Jesse Pollak (https://github.com/jes This product includes software developed by farzher (https://github.com/farzher/fuzzysort) This product includes software developed by Inorganik (https://inorganik.github.io/countUp.js/) This product includes software developed by ZXing for JS (https://github.com/zxing-js/library) +This product includes software developed by Hakim El Hattab, http://hakim.se, and reveal.js contributors (https://github.com/hakimel/reveal.js) diff --git a/core/src/main/resources/META-INF/faces-config.xml b/core/src/main/resources/META-INF/faces-config.xml index a7c516ae7..9a6536cc4 100755 --- a/core/src/main/resources/META-INF/faces-config.xml +++ b/core/src/main/resources/META-INF/faces-config.xml @@ -186,6 +186,14 @@ org.primefaces.extensions.component.InputPhone org.primefaces.extensions.component.inputphone.InputPhone + + org.primefaces.extensions.component.Keynote + org.primefaces.extensions.component.keynote.Keynote + + + org.primefaces.extensions.component.UIKeynoteItem + org.primefaces.extensions.component.keynote.UIKeynoteItem + org.primefaces.extensions.component.TimeAgo org.primefaces.extensions.component.timeago.TimeAgo @@ -384,6 +392,16 @@ org.primefaces.extensions.component.InputPhoneRenderer org.primefaces.extensions.component.inputphone.InputPhoneRenderer + + org.primefaces.extensions.component + org.primefaces.extensions.component.KeynoteRenderer + org.primefaces.extensions.component.keynote.KeynoteRenderer + + + org.primefaces.extensions.component + org.primefaces.extensions.component.KeynoteItemRenderer + org.primefaces.extensions.component.keynote.KeynoteItemRenderer + org.primefaces.extensions.component org.primefaces.extensions.component.TimeAgoRenderer diff --git a/core/src/main/resources/META-INF/primefaces-extensions.taglib.xml b/core/src/main/resources/META-INF/primefaces-extensions.taglib.xml index 9c6410b72..10f45ac99 100755 --- a/core/src/main/resources/META-INF/primefaces-extensions.taglib.xml +++ b/core/src/main/resources/META-INF/primefaces-extensions.taglib.xml @@ -8532,6 +8532,413 @@ See showcase for an example. Default null.]]> + + + + + keynote + + org.primefaces.extensions.component.Keynote + org.primefaces.extensions.component.KeynoteRenderer + + + + + + id + false + java.lang.String + + + + + + rendered + false + java.lang.Boolean + + + + + + binding + false + javax.faces.component.UIComponent + + + + + + widgetVar + false + java.lang.String + + + + + + value + false + java.lang.Object + + + + + + var + false + java.lang.String + + + + + + width + false + java.lang.Integer + + + + + + height + false + java.lang.Integer + + + + + + margin + false + java.lang.Double + + + + + + minScale + false + java.lang.Double + + + + + + maxScale + false + java.lang.Double + + + + + + autoSlide + false + java.lang.Integer + + + + + + center + false + java.lang.Boolean + + + + + + controls + false + java.lang.Boolean + + + + + + disableLayout + false + java.lang.Boolean + + + + + + embedded + false + java.lang.Boolean + + + + + + loop + false + java.lang.Boolean + + + + + + navigationMode + false + java.lang.String + + + + + + progress + false + java.lang.Boolean + + + + + + showNotes + false + java.lang.Boolean + + + + + + slideNumber + false + java.lang.String + + + + + + touch + false + java.lang.Boolean + + + + + + transition + false + java.lang.String + + + + + + transitionSpeed + false + java.lang.String + + + + + + backgroundTransition + false + java.lang.String + + + + + + theme + false + java.lang.String + + + + + + library + false + java.lang.String + + + + + + styleClass + false + java.lang.String + + + + + + style + false + java.lang.String + + + + + + + keynoteItem + + org.primefaces.extensions.component.UIKeynoteItem + org.primefaces.extensions.component.KeynoteItemRenderer + + + + + + id + false + java.lang.String + + + + + + rendered + false + java.lang.Boolean + + + + + + binding + false + javax.faces.component.UIOutput + + + + + + backgroundColor + false + java.lang.Boolean + + + + + + backgroundImage + false + java.lang.String + + + + + + backgroundSize + false + java.lang.String + + + + + + backgroundPosition + false + java.lang.String + + + + + + backgroundRepeat + false + java.lang.String + + + + + + backgroundOpacity + false + java.lang.Double + + + + + + backgroundVideo + false + java.lang.String + + + + + + backgroundVideoLoop + false + java.lang.Boolean + + + + + + backgroundVideoMuted + false + java.lang.Boolean + + + + + + markdown + false + java.lang.Boolean + + + + + + note + false + java.lang.String + + + + + + separator + false + java.lang.String + + + + + + separatorVertical + false + java.lang.String + + + + + + styleClass + false + java.lang.String + + + + + + type + false + java.lang.String + + + + + + visibility + false + java.lang.String + + + diff --git a/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/LICENSE b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/LICENSE new file mode 100644 index 000000000..807bc62aa --- /dev/null +++ b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/LICENSE @@ -0,0 +1,19 @@ +Copyright (C) 2011-2021 Hakim El Hattab, http://hakim.se, and reveal.js contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.css b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.css new file mode 100644 index 000000000..c3a2ecbb8 --- /dev/null +++ b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.css @@ -0,0 +1,8 @@ +/*! +* reveal.js 4.2.0 +* https://revealjs.com +* MIT licensed +* +* Copyright (C) 2011-2021 Hakim El Hattab, https://hakim.se +*/ +.reveal .r-stretch,.reveal .stretch{max-width:none;max-height:none}.reveal pre.r-stretch code,.reveal pre.stretch code{height:100%;max-height:100%;box-sizing:border-box}.reveal .r-fit-text{display:inline-block;white-space:nowrap}.reveal .r-stack{display:grid}.reveal .r-stack>*{grid-area:1/1;margin:auto}.reveal .r-hstack,.reveal .r-vstack{display:flex}.reveal .r-hstack img,.reveal .r-hstack video,.reveal .r-vstack img,.reveal .r-vstack video{min-width:0;min-height:0;-o-object-fit:contain;object-fit:contain}.reveal .r-vstack{flex-direction:column;align-items:center;justify-content:center}.reveal .r-hstack{flex-direction:row;align-items:center;justify-content:center}.reveal .items-stretch{align-items:stretch}.reveal .items-start{align-items:flex-start}.reveal .items-center{align-items:center}.reveal .items-end{align-items:flex-end}.reveal .justify-between{justify-content:space-between}.reveal .justify-around{justify-content:space-around}.reveal .justify-start{justify-content:flex-start}.reveal .justify-center{justify-content:center}.reveal .justify-end{justify-content:flex-end}html.reveal-full-page{width:100%;height:100%;height:100vh;height:calc(var(--vh,1vh) * 100);overflow:hidden}.reveal-viewport{height:100%;overflow:hidden;position:relative;line-height:1;margin:0;background-color:#fff;color:#000}.reveal .slides section .fragment{opacity:0;visibility:hidden;transition:all .2s ease;will-change:opacity}.reveal .slides section .fragment.visible{opacity:1;visibility:inherit}.reveal .slides section .fragment.disabled{transition:none}.reveal .slides section .fragment.grow{opacity:1;visibility:inherit}.reveal .slides section .fragment.grow.visible{transform:scale(1.3)}.reveal .slides section .fragment.shrink{opacity:1;visibility:inherit}.reveal .slides section .fragment.shrink.visible{transform:scale(.7)}.reveal .slides section .fragment.zoom-in{transform:scale(.1)}.reveal .slides section .fragment.zoom-in.visible{transform:none}.reveal .slides section .fragment.fade-out{opacity:1;visibility:inherit}.reveal .slides section .fragment.fade-out.visible{opacity:0;visibility:hidden}.reveal .slides section .fragment.semi-fade-out{opacity:1;visibility:inherit}.reveal .slides section .fragment.semi-fade-out.visible{opacity:.5;visibility:inherit}.reveal .slides section .fragment.strike{opacity:1;visibility:inherit}.reveal .slides section .fragment.strike.visible{text-decoration:line-through}.reveal .slides section .fragment.fade-up{transform:translate(0,40px)}.reveal .slides section .fragment.fade-up.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-down{transform:translate(0,-40px)}.reveal .slides section .fragment.fade-down.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-right{transform:translate(-40px,0)}.reveal .slides section .fragment.fade-right.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-left{transform:translate(40px,0)}.reveal .slides section .fragment.fade-left.visible{transform:translate(0,0)}.reveal .slides section .fragment.current-visible,.reveal .slides section .fragment.fade-in-then-out{opacity:0;visibility:hidden}.reveal .slides section .fragment.current-visible.current-fragment,.reveal .slides section .fragment.fade-in-then-out.current-fragment{opacity:1;visibility:inherit}.reveal .slides section .fragment.fade-in-then-semi-out{opacity:0;visibility:hidden}.reveal .slides section .fragment.fade-in-then-semi-out.visible{opacity:.5;visibility:inherit}.reveal .slides section .fragment.fade-in-then-semi-out.current-fragment{opacity:1;visibility:inherit}.reveal .slides section .fragment.highlight-blue,.reveal .slides section .fragment.highlight-current-blue,.reveal .slides section .fragment.highlight-current-green,.reveal .slides section .fragment.highlight-current-red,.reveal .slides section .fragment.highlight-green,.reveal .slides section .fragment.highlight-red{opacity:1;visibility:inherit}.reveal .slides section .fragment.highlight-red.visible{color:#ff2c2d}.reveal .slides section .fragment.highlight-green.visible{color:#17ff2e}.reveal .slides section .fragment.highlight-blue.visible{color:#1b91ff}.reveal .slides section .fragment.highlight-current-red.current-fragment{color:#ff2c2d}.reveal .slides section .fragment.highlight-current-green.current-fragment{color:#17ff2e}.reveal .slides section .fragment.highlight-current-blue.current-fragment{color:#1b91ff}.reveal:after{content:"";font-style:italic}.reveal iframe{z-index:1}.reveal a{position:relative}@keyframes bounce-right{0%,10%,25%,40%,50%{transform:translateX(0)}20%{transform:translateX(10px)}30%{transform:translateX(-5px)}}@keyframes bounce-left{0%,10%,25%,40%,50%{transform:translateX(0)}20%{transform:translateX(-10px)}30%{transform:translateX(5px)}}@keyframes bounce-down{0%,10%,25%,40%,50%{transform:translateY(0)}20%{transform:translateY(10px)}30%{transform:translateY(-5px)}}.reveal .controls{display:none;position:absolute;top:auto;bottom:12px;right:12px;left:auto;z-index:11;color:#000;pointer-events:none;font-size:10px}.reveal .controls button{position:absolute;padding:0;background-color:transparent;border:0;outline:0;cursor:pointer;color:currentColor;transform:scale(.9999);transition:color .2s ease,opacity .2s ease,transform .2s ease;z-index:2;pointer-events:auto;font-size:inherit;visibility:hidden;opacity:0;-webkit-appearance:none;-webkit-tap-highlight-color:transparent}.reveal .controls .controls-arrow:after,.reveal .controls .controls-arrow:before{content:"";position:absolute;top:0;left:0;width:2.6em;height:.5em;border-radius:.25em;background-color:currentColor;transition:all .15s ease,background-color .8s ease;transform-origin:.2em 50%;will-change:transform}.reveal .controls .controls-arrow{position:relative;width:3.6em;height:3.6em}.reveal .controls .controls-arrow:before{transform:translateX(.5em) translateY(1.55em) rotate(45deg)}.reveal .controls .controls-arrow:after{transform:translateX(.5em) translateY(1.55em) rotate(-45deg)}.reveal .controls .controls-arrow:hover:before{transform:translateX(.5em) translateY(1.55em) rotate(40deg)}.reveal .controls .controls-arrow:hover:after{transform:translateX(.5em) translateY(1.55em) rotate(-40deg)}.reveal .controls .controls-arrow:active:before{transform:translateX(.5em) translateY(1.55em) rotate(36deg)}.reveal .controls .controls-arrow:active:after{transform:translateX(.5em) translateY(1.55em) rotate(-36deg)}.reveal .controls .navigate-left{right:6.4em;bottom:3.2em;transform:translateX(-10px)}.reveal .controls .navigate-left.highlight{animation:bounce-left 2s 50 both ease-out}.reveal .controls .navigate-right{right:0;bottom:3.2em;transform:translateX(10px)}.reveal .controls .navigate-right .controls-arrow{transform:rotate(180deg)}.reveal .controls .navigate-right.highlight{animation:bounce-right 2s 50 both ease-out}.reveal .controls .navigate-up{right:3.2em;bottom:6.4em;transform:translateY(-10px)}.reveal .controls .navigate-up .controls-arrow{transform:rotate(90deg)}.reveal .controls .navigate-down{right:3.2em;bottom:-1.4em;padding-bottom:1.4em;transform:translateY(10px)}.reveal .controls .navigate-down .controls-arrow{transform:rotate(-90deg)}.reveal .controls .navigate-down.highlight{animation:bounce-down 2s 50 both ease-out}.reveal .controls[data-controls-back-arrows=faded] .navigate-up.enabled{opacity:.3}.reveal .controls[data-controls-back-arrows=faded] .navigate-up.enabled:hover{opacity:1}.reveal .controls[data-controls-back-arrows=hidden] .navigate-up.enabled{opacity:0;visibility:hidden}.reveal .controls .enabled{visibility:visible;opacity:.9;cursor:pointer;transform:none}.reveal .controls .enabled.fragmented{opacity:.5}.reveal .controls .enabled.fragmented:hover,.reveal .controls .enabled:hover{opacity:1}.reveal:not(.rtl) .controls[data-controls-back-arrows=faded] .navigate-left.enabled{opacity:.3}.reveal:not(.rtl) .controls[data-controls-back-arrows=faded] .navigate-left.enabled:hover{opacity:1}.reveal:not(.rtl) .controls[data-controls-back-arrows=hidden] .navigate-left.enabled{opacity:0;visibility:hidden}.reveal.rtl .controls[data-controls-back-arrows=faded] .navigate-right.enabled{opacity:.3}.reveal.rtl .controls[data-controls-back-arrows=faded] .navigate-right.enabled:hover{opacity:1}.reveal.rtl .controls[data-controls-back-arrows=hidden] .navigate-right.enabled{opacity:0;visibility:hidden}.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-down,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-up{display:none}.reveal:not(.has-vertical-slides) .controls .navigate-left,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-left{bottom:1.4em;right:5.5em}.reveal:not(.has-vertical-slides) .controls .navigate-right,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-right{bottom:1.4em;right:.5em}.reveal:not(.has-horizontal-slides) .controls .navigate-up{right:1.4em;bottom:5em}.reveal:not(.has-horizontal-slides) .controls .navigate-down{right:1.4em;bottom:.5em}.reveal.has-dark-background .controls{color:#fff}.reveal.has-light-background .controls{color:#000}.reveal.no-hover .controls .controls-arrow:active:before,.reveal.no-hover .controls .controls-arrow:hover:before{transform:translateX(.5em) translateY(1.55em) rotate(45deg)}.reveal.no-hover .controls .controls-arrow:active:after,.reveal.no-hover .controls .controls-arrow:hover:after{transform:translateX(.5em) translateY(1.55em) rotate(-45deg)}@media screen and (min-width:500px){.reveal .controls[data-controls-layout=edges]{top:0;right:0;bottom:0;left:0}.reveal .controls[data-controls-layout=edges] .navigate-down,.reveal .controls[data-controls-layout=edges] .navigate-left,.reveal .controls[data-controls-layout=edges] .navigate-right,.reveal .controls[data-controls-layout=edges] .navigate-up{bottom:auto;right:auto}.reveal .controls[data-controls-layout=edges] .navigate-left{top:50%;left:.8em;margin-top:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-right{top:50%;right:.8em;margin-top:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-up{top:.8em;left:50%;margin-left:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-down{bottom:-.3em;left:50%;margin-left:-1.8em}}.reveal .progress{position:absolute;display:none;height:3px;width:100%;bottom:0;left:0;z-index:10;background-color:rgba(0,0,0,.2);color:#fff}.reveal .progress:after{content:"";display:block;position:absolute;height:10px;width:100%;top:-10px}.reveal .progress span{display:block;height:100%;width:100%;background-color:currentColor;transition:transform .8s cubic-bezier(.26,.86,.44,.985);transform-origin:0 0;transform:scaleX(0)}.reveal .slide-number{position:absolute;display:block;right:8px;bottom:8px;z-index:31;font-family:Helvetica,sans-serif;font-size:12px;line-height:1;color:#fff;background-color:rgba(0,0,0,.4);padding:5px}.reveal .slide-number a{color:currentColor}.reveal .slide-number-delimiter{margin:0 3px}.reveal{position:relative;width:100%;height:100%;overflow:hidden;touch-action:pinch-zoom}.reveal.embedded{touch-action:pan-y}.reveal .slides{position:absolute;width:100%;height:100%;top:0;right:0;bottom:0;left:0;margin:auto;pointer-events:none;overflow:visible;z-index:1;text-align:center;perspective:600px;perspective-origin:50% 40%}.reveal .slides>section{perspective:600px}.reveal .slides>section,.reveal .slides>section>section{display:none;position:absolute;width:100%;pointer-events:auto;z-index:10;transform-style:flat;transition:transform-origin .8s cubic-bezier(.26,.86,.44,.985),transform .8s cubic-bezier(.26,.86,.44,.985),visibility .8s cubic-bezier(.26,.86,.44,.985),opacity .8s cubic-bezier(.26,.86,.44,.985)}.reveal[data-transition-speed=fast] .slides section{transition-duration:.4s}.reveal[data-transition-speed=slow] .slides section{transition-duration:1.2s}.reveal .slides section[data-transition-speed=fast]{transition-duration:.4s}.reveal .slides section[data-transition-speed=slow]{transition-duration:1.2s}.reveal .slides>section.stack{padding-top:0;padding-bottom:0;pointer-events:none;height:100%}.reveal .slides>section.present,.reveal .slides>section>section.present{display:block;z-index:11;opacity:1}.reveal .slides>section:empty,.reveal .slides>section>section:empty,.reveal .slides>section>section[data-background-interactive],.reveal .slides>section[data-background-interactive]{pointer-events:none}.reveal.center,.reveal.center .slides,.reveal.center .slides section{min-height:0!important}.reveal .slides>section:not(.present),.reveal .slides>section>section:not(.present){pointer-events:none}.reveal.overview .slides>section,.reveal.overview .slides>section>section{pointer-events:auto}.reveal .slides>section.future,.reveal .slides>section.past,.reveal .slides>section>section.future,.reveal .slides>section>section.past{opacity:0}.reveal.slide section{-webkit-backface-visibility:hidden;backface-visibility:hidden}.reveal .slides>section[data-transition=slide].past,.reveal .slides>section[data-transition~=slide-out].past,.reveal.slide .slides>section:not([data-transition]).past{transform:translate(-150%,0)}.reveal .slides>section[data-transition=slide].future,.reveal .slides>section[data-transition~=slide-in].future,.reveal.slide .slides>section:not([data-transition]).future{transform:translate(150%,0)}.reveal .slides>section>section[data-transition=slide].past,.reveal .slides>section>section[data-transition~=slide-out].past,.reveal.slide .slides>section>section:not([data-transition]).past{transform:translate(0,-150%)}.reveal .slides>section>section[data-transition=slide].future,.reveal .slides>section>section[data-transition~=slide-in].future,.reveal.slide .slides>section>section:not([data-transition]).future{transform:translate(0,150%)}.reveal.linear section{-webkit-backface-visibility:hidden;backface-visibility:hidden}.reveal .slides>section[data-transition=linear].past,.reveal .slides>section[data-transition~=linear-out].past,.reveal.linear .slides>section:not([data-transition]).past{transform:translate(-150%,0)}.reveal .slides>section[data-transition=linear].future,.reveal .slides>section[data-transition~=linear-in].future,.reveal.linear .slides>section:not([data-transition]).future{transform:translate(150%,0)}.reveal .slides>section>section[data-transition=linear].past,.reveal .slides>section>section[data-transition~=linear-out].past,.reveal.linear .slides>section>section:not([data-transition]).past{transform:translate(0,-150%)}.reveal .slides>section>section[data-transition=linear].future,.reveal .slides>section>section[data-transition~=linear-in].future,.reveal.linear .slides>section>section:not([data-transition]).future{transform:translate(0,150%)}.reveal .slides section[data-transition=default].stack,.reveal.default .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=default].past,.reveal .slides>section[data-transition~=default-out].past,.reveal.default .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=default].future,.reveal .slides>section[data-transition~=default-in].future,.reveal.default .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=default].past,.reveal .slides>section>section[data-transition~=default-out].past,.reveal.default .slides>section>section:not([data-transition]).past{transform:translate3d(0,-300px,0) rotateX(70deg) translate3d(0,-300px,0)}.reveal .slides>section>section[data-transition=default].future,.reveal .slides>section>section[data-transition~=default-in].future,.reveal.default .slides>section>section:not([data-transition]).future{transform:translate3d(0,300px,0) rotateX(-70deg) translate3d(0,300px,0)}.reveal .slides section[data-transition=convex].stack,.reveal.convex .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=convex].past,.reveal .slides>section[data-transition~=convex-out].past,.reveal.convex .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=convex].future,.reveal .slides>section[data-transition~=convex-in].future,.reveal.convex .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=convex].past,.reveal .slides>section>section[data-transition~=convex-out].past,.reveal.convex .slides>section>section:not([data-transition]).past{transform:translate3d(0,-300px,0) rotateX(70deg) translate3d(0,-300px,0)}.reveal .slides>section>section[data-transition=convex].future,.reveal .slides>section>section[data-transition~=convex-in].future,.reveal.convex .slides>section>section:not([data-transition]).future{transform:translate3d(0,300px,0) rotateX(-70deg) translate3d(0,300px,0)}.reveal .slides section[data-transition=concave].stack,.reveal.concave .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=concave].past,.reveal .slides>section[data-transition~=concave-out].past,.reveal.concave .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=concave].future,.reveal .slides>section[data-transition~=concave-in].future,.reveal.concave .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(-90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=concave].past,.reveal .slides>section>section[data-transition~=concave-out].past,.reveal.concave .slides>section>section:not([data-transition]).past{transform:translate3d(0,-80%,0) rotateX(-70deg) translate3d(0,-80%,0)}.reveal .slides>section>section[data-transition=concave].future,.reveal .slides>section>section[data-transition~=concave-in].future,.reveal.concave .slides>section>section:not([data-transition]).future{transform:translate3d(0,80%,0) rotateX(70deg) translate3d(0,80%,0)}.reveal .slides section[data-transition=zoom],.reveal.zoom .slides section:not([data-transition]){transition-timing-function:ease}.reveal .slides>section[data-transition=zoom].past,.reveal .slides>section[data-transition~=zoom-out].past,.reveal.zoom .slides>section:not([data-transition]).past{visibility:hidden;transform:scale(16)}.reveal .slides>section[data-transition=zoom].future,.reveal .slides>section[data-transition~=zoom-in].future,.reveal.zoom .slides>section:not([data-transition]).future{visibility:hidden;transform:scale(.2)}.reveal .slides>section>section[data-transition=zoom].past,.reveal .slides>section>section[data-transition~=zoom-out].past,.reveal.zoom .slides>section>section:not([data-transition]).past{transform:scale(16)}.reveal .slides>section>section[data-transition=zoom].future,.reveal .slides>section>section[data-transition~=zoom-in].future,.reveal.zoom .slides>section>section:not([data-transition]).future{transform:scale(.2)}.reveal.cube .slides{perspective:1300px}.reveal.cube .slides section{padding:30px;min-height:700px;-webkit-backface-visibility:hidden;backface-visibility:hidden;box-sizing:border-box;transform-style:preserve-3d}.reveal.center.cube .slides section{min-height:0}.reveal.cube .slides section:not(.stack):before{content:"";position:absolute;display:block;width:100%;height:100%;left:0;top:0;background:rgba(0,0,0,.1);border-radius:4px;transform:translateZ(-20px)}.reveal.cube .slides section:not(.stack):after{content:"";position:absolute;display:block;width:90%;height:30px;left:5%;bottom:0;background:0 0;z-index:1;border-radius:4px;box-shadow:0 95px 25px rgba(0,0,0,.2);transform:translateZ(-90px) rotateX(65deg)}.reveal.cube .slides>section.stack{padding:0;background:0 0}.reveal.cube .slides>section.past{transform-origin:100% 0;transform:translate3d(-100%,0,0) rotateY(-90deg)}.reveal.cube .slides>section.future{transform-origin:0 0;transform:translate3d(100%,0,0) rotateY(90deg)}.reveal.cube .slides>section>section.past{transform-origin:0 100%;transform:translate3d(0,-100%,0) rotateX(90deg)}.reveal.cube .slides>section>section.future{transform-origin:0 0;transform:translate3d(0,100%,0) rotateX(-90deg)}.reveal.page .slides{perspective-origin:0 50%;perspective:3000px}.reveal.page .slides section{padding:30px;min-height:700px;box-sizing:border-box;transform-style:preserve-3d}.reveal.page .slides section.past{z-index:12}.reveal.page .slides section:not(.stack):before{content:"";position:absolute;display:block;width:100%;height:100%;left:0;top:0;background:rgba(0,0,0,.1);transform:translateZ(-20px)}.reveal.page .slides section:not(.stack):after{content:"";position:absolute;display:block;width:90%;height:30px;left:5%;bottom:0;background:0 0;z-index:1;border-radius:4px;box-shadow:0 95px 25px rgba(0,0,0,.2);-webkit-transform:translateZ(-90px) rotateX(65deg)}.reveal.page .slides>section.stack{padding:0;background:0 0}.reveal.page .slides>section.past{transform-origin:0 0;transform:translate3d(-40%,0,0) rotateY(-80deg)}.reveal.page .slides>section.future{transform-origin:100% 0;transform:translate3d(0,0,0)}.reveal.page .slides>section>section.past{transform-origin:0 0;transform:translate3d(0,-40%,0) rotateX(80deg)}.reveal.page .slides>section>section.future{transform-origin:0 100%;transform:translate3d(0,0,0)}.reveal .slides section[data-transition=fade],.reveal.fade .slides section:not([data-transition]),.reveal.fade .slides>section>section:not([data-transition]){transform:none;transition:opacity .5s}.reveal.fade.overview .slides section,.reveal.fade.overview .slides>section>section{transition:none}.reveal .slides section[data-transition=none],.reveal.none .slides section:not([data-transition]){transform:none;transition:none}.reveal .pause-overlay{position:absolute;top:0;left:0;width:100%;height:100%;background:#000;visibility:hidden;opacity:0;z-index:100;transition:all 1s ease}.reveal .pause-overlay .resume-button{position:absolute;bottom:20px;right:20px;color:#ccc;border-radius:2px;padding:6px 14px;border:2px solid #ccc;font-size:16px;background:0 0;cursor:pointer}.reveal .pause-overlay .resume-button:hover{color:#fff;border-color:#fff}.reveal.paused .pause-overlay{visibility:visible;opacity:1}.reveal .no-transition,.reveal .no-transition *,.reveal .slides.disable-slide-transitions section{transition:none!important}.reveal .slides.disable-slide-transitions section{transform:none!important}.reveal .backgrounds{position:absolute;width:100%;height:100%;top:0;left:0;perspective:600px}.reveal .slide-background{display:none;position:absolute;width:100%;height:100%;opacity:0;visibility:hidden;overflow:hidden;background-color:rgba(0,0,0,0);transition:all .8s cubic-bezier(.26,.86,.44,.985)}.reveal .slide-background-content{position:absolute;width:100%;height:100%;background-position:50% 50%;background-repeat:no-repeat;background-size:cover}.reveal .slide-background.stack{display:block}.reveal .slide-background.present{opacity:1;visibility:visible;z-index:2}.print-pdf .reveal .slide-background{opacity:1!important;visibility:visible!important}.reveal .slide-background video{position:absolute;width:100%;height:100%;max-width:none;max-height:none;top:0;left:0;-o-object-fit:cover;object-fit:cover}.reveal .slide-background[data-background-size=contain] video{-o-object-fit:contain;object-fit:contain}.reveal>.backgrounds .slide-background[data-background-transition=none],.reveal[data-background-transition=none]>.backgrounds .slide-background:not([data-background-transition]){transition:none}.reveal>.backgrounds .slide-background[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background:not([data-background-transition]){opacity:1;-webkit-backface-visibility:hidden;backface-visibility:hidden}.reveal>.backgrounds .slide-background.past[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background.past:not([data-background-transition]){transform:translate(-100%,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background.future:not([data-background-transition]){transform:translate(100%,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){transform:translate(0,-100%)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){transform:translate(0,100%)}.reveal>.backgrounds .slide-background.past[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(0,-100%,0) rotateX(90deg) translate3d(0,-100%,0)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(0,100%,0) rotateX(-90deg) translate3d(0,100%,0)}.reveal>.backgrounds .slide-background.past[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(-100%,0,0) rotateY(90deg) translate3d(-100%,0,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(100%,0,0) rotateY(-90deg) translate3d(100%,0,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(0,-100%,0) rotateX(-90deg) translate3d(0,-100%,0)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(0,100%,0) rotateX(90deg) translate3d(0,100%,0)}.reveal>.backgrounds .slide-background[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background:not([data-background-transition]){transition-timing-function:ease}.reveal>.backgrounds .slide-background.past[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(16)}.reveal>.backgrounds .slide-background.future[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(.2)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(16)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(.2)}.reveal[data-transition-speed=fast]>.backgrounds .slide-background{transition-duration:.4s}.reveal[data-transition-speed=slow]>.backgrounds .slide-background{transition-duration:1.2s}.reveal [data-auto-animate-target^=unmatched]{will-change:opacity}.reveal section[data-auto-animate]:not(.stack):not([data-auto-animate=running]) [data-auto-animate-target^=unmatched]{opacity:0}.reveal.overview{perspective-origin:50% 50%;perspective:700px}.reveal.overview .slides{-moz-transform-style:preserve-3d}.reveal.overview .slides section{height:100%;top:0!important;opacity:1!important;overflow:hidden;visibility:visible!important;cursor:pointer;box-sizing:border-box}.reveal.overview .slides section.present,.reveal.overview .slides section:hover{outline:10px solid rgba(150,150,150,.4);outline-offset:10px}.reveal.overview .slides section .fragment{opacity:1;transition:none}.reveal.overview .slides section:after,.reveal.overview .slides section:before{display:none!important}.reveal.overview .slides>section.stack{padding:0;top:0!important;background:0 0;outline:0;overflow:visible}.reveal.overview .backgrounds{perspective:inherit;-moz-transform-style:preserve-3d}.reveal.overview .backgrounds .slide-background{opacity:1;visibility:visible;outline:10px solid rgba(150,150,150,.1);outline-offset:10px}.reveal.overview .backgrounds .slide-background.stack{overflow:visible}.reveal.overview .slides section,.reveal.overview-deactivating .slides section{transition:none}.reveal.overview .backgrounds .slide-background,.reveal.overview-deactivating .backgrounds .slide-background{transition:none}.reveal.rtl .slides,.reveal.rtl .slides h1,.reveal.rtl .slides h2,.reveal.rtl .slides h3,.reveal.rtl .slides h4,.reveal.rtl .slides h5,.reveal.rtl .slides h6{direction:rtl;font-family:sans-serif}.reveal.rtl code,.reveal.rtl pre{direction:ltr}.reveal.rtl ol,.reveal.rtl ul{text-align:right}.reveal.rtl .progress span{transform-origin:100% 0}.reveal.has-parallax-background .backgrounds{transition:all .8s ease}.reveal.has-parallax-background[data-transition-speed=fast] .backgrounds{transition-duration:.4s}.reveal.has-parallax-background[data-transition-speed=slow] .backgrounds{transition-duration:1.2s}.reveal>.overlay{position:absolute;top:0;left:0;width:100%;height:100%;z-index:1000;background:rgba(0,0,0,.9);transition:all .3s ease}.reveal>.overlay .spinner{position:absolute;display:block;top:50%;left:50%;width:32px;height:32px;margin:-16px 0 0 -16px;z-index:10;background-image:url(data:image/gif;base64,R0lGODlhIAAgAPMAAJmZmf%2F%2F%2F6%2Bvr8nJybW1tcDAwOjo6Nvb26ioqKOjo7Ozs%2FLy8vz8%2FAAAAAAAAAAAACH%2FC05FVFNDQVBFMi4wAwEAAAAh%2FhpDcmVhdGVkIHdpdGggYWpheGxvYWQuaW5mbwAh%2BQQJCgAAACwAAAAAIAAgAAAE5xDISWlhperN52JLhSSdRgwVo1ICQZRUsiwHpTJT4iowNS8vyW2icCF6k8HMMBkCEDskxTBDAZwuAkkqIfxIQyhBQBFvAQSDITM5VDW6XNE4KagNh6Bgwe60smQUB3d4Rz1ZBApnFASDd0hihh12BkE9kjAJVlycXIg7CQIFA6SlnJ87paqbSKiKoqusnbMdmDC2tXQlkUhziYtyWTxIfy6BE8WJt5YJvpJivxNaGmLHT0VnOgSYf0dZXS7APdpB309RnHOG5gDqXGLDaC457D1zZ%2FV%2FnmOM82XiHRLYKhKP1oZmADdEAAAh%2BQQJCgAAACwAAAAAIAAgAAAE6hDISWlZpOrNp1lGNRSdRpDUolIGw5RUYhhHukqFu8DsrEyqnWThGvAmhVlteBvojpTDDBUEIFwMFBRAmBkSgOrBFZogCASwBDEY%2FCZSg7GSE0gSCjQBMVG023xWBhklAnoEdhQEfyNqMIcKjhRsjEdnezB%2BA4k8gTwJhFuiW4dokXiloUepBAp5qaKpp6%2BHo7aWW54wl7obvEe0kRuoplCGepwSx2jJvqHEmGt6whJpGpfJCHmOoNHKaHx61WiSR92E4lbFoq%2BB6QDtuetcaBPnW6%2BO7wDHpIiK9SaVK5GgV543tzjgGcghAgAh%2BQQJCgAAACwAAAAAIAAgAAAE7hDISSkxpOrN5zFHNWRdhSiVoVLHspRUMoyUakyEe8PTPCATW9A14E0UvuAKMNAZKYUZCiBMuBakSQKG8G2FzUWox2AUtAQFcBKlVQoLgQReZhQlCIJesQXI5B0CBnUMOxMCenoCfTCEWBsJColTMANldx15BGs8B5wlCZ9Po6OJkwmRpnqkqnuSrayqfKmqpLajoiW5HJq7FL1Gr2mMMcKUMIiJgIemy7xZtJsTmsM4xHiKv5KMCXqfyUCJEonXPN2rAOIAmsfB3uPoAK%2B%2BG%2Bw48edZPK%2BM6hLJpQg484enXIdQFSS1u6UhksENEQAAIfkECQoAAAAsAAAAACAAIAAABOcQyEmpGKLqzWcZRVUQnZYg1aBSh2GUVEIQ2aQOE%2BG%2BcD4ntpWkZQj1JIiZIogDFFyHI0UxQwFugMSOFIPJftfVAEoZLBbcLEFhlQiqGp1Vd140AUklUN3eCA51C1EWMzMCezCBBmkxVIVHBWd3HHl9JQOIJSdSnJ0TDKChCwUJjoWMPaGqDKannasMo6WnM562R5YluZRwur0wpgqZE7NKUm%2BFNRPIhjBJxKZteWuIBMN4zRMIVIhffcgojwCF117i4nlLnY5ztRLsnOk%2BaV%2BoJY7V7m76PdkS4trKcdg0Zc0tTcKkRAAAIfkECQoAAAAsAAAAACAAIAAABO4QyEkpKqjqzScpRaVkXZWQEximw1BSCUEIlDohrft6cpKCk5xid5MNJTaAIkekKGQkWyKHkvhKsR7ARmitkAYDYRIbUQRQjWBwJRzChi9CRlBcY1UN4g0%2FVNB0AlcvcAYHRyZPdEQFYV8ccwR5HWxEJ02YmRMLnJ1xCYp0Y5idpQuhopmmC2KgojKasUQDk5BNAwwMOh2RtRq5uQuPZKGIJQIGwAwGf6I0JXMpC8C7kXWDBINFMxS4DKMAWVWAGYsAdNqW5uaRxkSKJOZKaU3tPOBZ4DuK2LATgJhkPJMgTwKCdFjyPHEnKxFCDhEAACH5BAkKAAAALAAAAAAgACAAAATzEMhJaVKp6s2nIkolIJ2WkBShpkVRWqqQrhLSEu9MZJKK9y1ZrqYK9WiClmvoUaF8gIQSNeF1Er4MNFn4SRSDARWroAIETg1iVwuHjYB1kYc1mwruwXKC9gmsJXliGxc%2BXiUCby9ydh1sOSdMkpMTBpaXBzsfhoc5l58Gm5yToAaZhaOUqjkDgCWNHAULCwOLaTmzswadEqggQwgHuQsHIoZCHQMMQgQGubVEcxOPFAcMDAYUA85eWARmfSRQCdcMe0zeP1AAygwLlJtPNAAL19DARdPzBOWSm1brJBi45soRAWQAAkrQIykShQ9wVhHCwCQCACH5BAkKAAAALAAAAAAgACAAAATrEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiRMDjI0Fd30%2FiI2UA5GSS5UDj2l6NoqgOgN4gksEBgYFf0FDqKgHnyZ9OX8HrgYHdHpcHQULXAS2qKpENRg7eAMLC7kTBaixUYFkKAzWAAnLC7FLVxLWDBLKCwaKTULgEwbLA4hJtOkSBNqITT3xEgfLpBtzE%2FjiuL04RGEBgwWhShRgQExHBAAh%2BQQJCgAAACwAAAAAIAAgAAAE7xDISWlSqerNpyJKhWRdlSAVoVLCWk6JKlAqAavhO9UkUHsqlE6CwO1cRdCQ8iEIfzFVTzLdRAmZX3I2SfZiCqGk5dTESJeaOAlClzsJsqwiJwiqnFrb2nS9kmIcgEsjQydLiIlHehhpejaIjzh9eomSjZR%2BipslWIRLAgMDOR2DOqKogTB9pCUJBagDBXR6XB0EBkIIsaRsGGMMAxoDBgYHTKJiUYEGDAzHC9EACcUGkIgFzgwZ0QsSBcXHiQvOwgDdEwfFs0sDzt4S6BK4xYjkDOzn0unFeBzOBijIm1Dgmg5YFQwsCMjp1oJ8LyIAACH5BAkKAAAALAAAAAAgACAAAATwEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiUd6GGl6NoiPOH16iZKNlH6KmyWFOggHhEEvAwwMA0N9GBsEC6amhnVcEwavDAazGwIDaH1ipaYLBUTCGgQDA8NdHz0FpqgTBwsLqAbWAAnIA4FWKdMLGdYGEgraigbT0OITBcg5QwPT4xLrROZL6AuQAPUS7bxLpoWidY0JtxLHKhwwMJBTHgPKdEQAACH5BAkKAAAALAAAAAAgACAAAATrEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiUd6GAULDJCRiXo1CpGXDJOUjY%2BYip9DhToJA4RBLwMLCwVDfRgbBAaqqoZ1XBMHswsHtxtFaH1iqaoGNgAIxRpbFAgfPQSqpbgGBqUD1wBXeCYp1AYZ19JJOYgH1KwA4UBvQwXUBxPqVD9L3sbp2BNk2xvvFPJd%2BMFCN6HAAIKgNggY0KtEBAAh%2BQQJCgAAACwAAAAAIAAgAAAE6BDISWlSqerNpyJKhWRdlSAVoVLCWk6JKlAqAavhO9UkUHsqlE6CwO1cRdCQ8iEIfzFVTzLdRAmZX3I2SfYIDMaAFdTESJeaEDAIMxYFqrOUaNW4E4ObYcCXaiBVEgULe0NJaxxtYksjh2NLkZISgDgJhHthkpU4mW6blRiYmZOlh4JWkDqILwUGBnE6TYEbCgevr0N1gH4At7gHiRpFaLNrrq8HNgAJA70AWxQIH1%2BvsYMDAzZQPC9VCNkDWUhGkuE5PxJNwiUK4UfLzOlD4WvzAHaoG9nxPi5d%2BjYUqfAhhykOFwJWiAAAIfkECQoAAAAsAAAAACAAIAAABPAQyElpUqnqzaciSoVkXVUMFaFSwlpOCcMYlErAavhOMnNLNo8KsZsMZItJEIDIFSkLGQoQTNhIsFehRww2CQLKF0tYGKYSg%2BygsZIuNqJksKgbfgIGepNo2cIUB3V1B3IvNiBYNQaDSTtfhhx0CwVPI0UJe0%2Bbm4g5VgcGoqOcnjmjqDSdnhgEoamcsZuXO1aWQy8KAwOAuTYYGwi7w5h%2BKr0SJ8MFihpNbx%2B4Erq7BYBuzsdiH1jCAzoSfl0rVirNbRXlBBlLX%2BBP0XJLAPGzTkAuAOqb0WT5AH7OcdCm5B8TgRwSRKIHQtaLCwg1RAAAOwAAAAAAAAAAAA%3D%3D);visibility:visible;opacity:.6;transition:all .3s ease}.reveal>.overlay header{position:absolute;left:0;top:0;width:100%;padding:5px;z-index:2;box-sizing:border-box}.reveal>.overlay header a{display:inline-block;width:40px;height:40px;line-height:36px;padding:0 10px;float:right;opacity:.6;box-sizing:border-box}.reveal>.overlay header a:hover{opacity:1}.reveal>.overlay header a .icon{display:inline-block;width:20px;height:20px;background-position:50% 50%;background-size:100%;background-repeat:no-repeat}.reveal>.overlay header a.close .icon{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABkklEQVRYR8WX4VHDMAxG6wnoJrABZQPYBCaBTWAD2g1gE5gg6OOsXuxIlr40d81dfrSJ9V4c2VLK7spHuTJ/5wpM07QXuXc5X0opX2tEJcadjHuV80li/FgxTIEK/5QBCICBD6xEhSMGHgQPgBgLiYVAB1dpSqKDawxTohFw4JSEA3clzgIBPCURwE2JucBR7rhPJJv5OpJwDX+SfDjgx1wACQeJG1aChP9K/IMmdZ8DtESV1WyP3Bt4MwM6sj4NMxMYiqUWHQu4KYA/SYkIjOsm3BXYWMKFDwU2khjCQ4ELJUJ4SmClRArOCmSXGuKma0fYD5CbzHxFpCSGAhfAVSSUGDUk2BWZaff2g6GE15BsBQ9nwmpIGDiyHQddwNTMKkbZaf9fajXQca1EX44puJZUsnY0ObGmITE3GVLCbEhQUjGVt146j6oasWN+49Vph2w1pZ5EansNZqKBm1txbU57iRRcZ86RWMDdWtBJUHBHwoQPi1GV+JCbntmvok7iTX4/Up9mgyTc/FJYDTcndgH/AA5A/CHsyEkVAAAAAElFTkSuQmCC)}.reveal>.overlay header a.external .icon{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAcElEQVRYR+2WSQoAIQwEzf8f7XiOMkUQxUPlGkM3hVmiQfQR9GYnH1SsAQlI4DiBqkCMoNb9y2e90IAEJPAcgdznU9+engMaeJ7Azh5Y1U67gAho4DqBqmB1buAf0MB1AlVBek83ZPkmJMGc1wAR+AAqod/B97TRpQAAAABJRU5ErkJggg==)}.reveal>.overlay .viewport{position:absolute;display:flex;top:50px;right:0;bottom:0;left:0}.reveal>.overlay.overlay-preview .viewport iframe{width:100%;height:100%;max-width:100%;max-height:100%;border:0;opacity:0;visibility:hidden;transition:all .3s ease}.reveal>.overlay.overlay-preview.loaded .viewport iframe{opacity:1;visibility:visible}.reveal>.overlay.overlay-preview.loaded .viewport-inner{position:absolute;z-index:-1;left:0;top:45%;width:100%;text-align:center;letter-spacing:normal}.reveal>.overlay.overlay-preview .x-frame-error{opacity:0;transition:opacity .3s ease .3s}.reveal>.overlay.overlay-preview.loaded .x-frame-error{opacity:1}.reveal>.overlay.overlay-preview.loaded .spinner{opacity:0;visibility:hidden;transform:scale(.2)}.reveal>.overlay.overlay-help .viewport{overflow:auto;color:#fff}.reveal>.overlay.overlay-help .viewport .viewport-inner{width:600px;margin:auto;padding:20px 20px 80px 20px;text-align:center;letter-spacing:normal}.reveal>.overlay.overlay-help .viewport .viewport-inner .title{font-size:20px}.reveal>.overlay.overlay-help .viewport .viewport-inner table{border:1px solid #fff;border-collapse:collapse;font-size:16px}.reveal>.overlay.overlay-help .viewport .viewport-inner table td,.reveal>.overlay.overlay-help .viewport .viewport-inner table th{width:200px;padding:14px;border:1px solid #fff;vertical-align:middle}.reveal>.overlay.overlay-help .viewport .viewport-inner table th{padding-top:20px;padding-bottom:20px}.reveal .playback{position:absolute;left:15px;bottom:20px;z-index:30;cursor:pointer;transition:all .4s ease;-webkit-tap-highlight-color:transparent}.reveal.overview .playback{opacity:0;visibility:hidden}.reveal .hljs{min-height:100%}.reveal .hljs table{margin:initial}.reveal .hljs-ln-code,.reveal .hljs-ln-numbers{padding:0;border:0}.reveal .hljs-ln-numbers{opacity:.6;padding-right:.75em;text-align:right;vertical-align:top}.reveal .hljs.has-highlights tr:not(.highlight-line){opacity:.4}.reveal .hljs:not(:first-child).fragment{position:absolute;top:0;left:0;width:100%;box-sizing:border-box}.reveal pre[data-auto-animate-target]{overflow:hidden}.reveal pre[data-auto-animate-target] code{height:100%}.reveal .roll{display:inline-block;line-height:1.2;overflow:hidden;vertical-align:top;perspective:400px;perspective-origin:50% 50%}.reveal .roll:hover{background:0 0;text-shadow:none}.reveal .roll span{display:block;position:relative;padding:0 2px;pointer-events:none;transition:all .4s ease;transform-origin:50% 0;transform-style:preserve-3d;-webkit-backface-visibility:hidden;backface-visibility:hidden}.reveal .roll:hover span{background:rgba(0,0,0,.5);transform:translate3d(0,0,-45px) rotateX(90deg)}.reveal .roll span:after{content:attr(data-title);display:block;position:absolute;left:0;top:0;padding:0 2px;-webkit-backface-visibility:hidden;backface-visibility:hidden;transform-origin:50% 0;transform:translate3d(0,110%,0) rotateX(-90deg)}.reveal aside.notes{display:none}.reveal .speaker-notes{display:none;position:absolute;width:33.3333333333%;height:100%;top:0;left:100%;padding:14px 18px 14px 18px;z-index:1;font-size:18px;line-height:1.4;border:1px solid rgba(0,0,0,.05);color:#222;background-color:#f5f5f5;overflow:auto;box-sizing:border-box;text-align:left;font-family:Helvetica,sans-serif;-webkit-overflow-scrolling:touch}.reveal .speaker-notes .notes-placeholder{color:#ccc;font-style:italic}.reveal .speaker-notes:focus{outline:0}.reveal .speaker-notes:before{content:"Speaker notes";display:block;margin-bottom:10px;opacity:.5}.reveal.show-notes{max-width:75%;overflow:visible}.reveal.show-notes .speaker-notes{display:block}@media screen and (min-width:1600px){.reveal .speaker-notes{font-size:20px}}@media screen and (max-width:1024px){.reveal.show-notes{border-left:0;max-width:none;max-height:70%;max-height:70vh;overflow:visible}.reveal.show-notes .speaker-notes{top:100%;left:0;width:100%;height:42.8571428571%;height:30vh;border:0}}@media screen and (max-width:600px){.reveal.show-notes{max-height:60%;max-height:60vh}.reveal.show-notes .speaker-notes{top:100%;height:66.6666666667%;height:40vh}.reveal .speaker-notes{font-size:14px}}.zoomed .reveal *,.zoomed .reveal :after,.zoomed .reveal :before{-webkit-backface-visibility:visible!important;backface-visibility:visible!important}.zoomed .reveal .controls,.zoomed .reveal .progress{opacity:0}.zoomed .reveal .roll span{background:0 0}.zoomed .reveal .roll span:after{visibility:hidden}html.print-pdf *{-webkit-print-color-adjust:exact}html.print-pdf{width:100%;height:100%;overflow:visible}html.print-pdf body{margin:0 auto!important;border:0;padding:0;float:none!important;overflow:visible}html.print-pdf .nestedarrow,html.print-pdf .reveal .controls,html.print-pdf .reveal .playback,html.print-pdf .reveal .progress,html.print-pdf .reveal.overview,html.print-pdf .state-background{display:none!important}html.print-pdf .reveal pre code{overflow:hidden!important;font-family:Courier,"Courier New",monospace!important}html.print-pdf .reveal{width:auto!important;height:auto!important;overflow:hidden!important}html.print-pdf .reveal .slides{position:static;width:100%!important;height:auto!important;zoom:1!important;pointer-events:initial;left:auto;top:auto;margin:0!important;padding:0!important;overflow:visible;display:block;perspective:none;perspective-origin:50% 50%}html.print-pdf .reveal .slides .pdf-page{position:relative;overflow:hidden;z-index:1;page-break-after:always}html.print-pdf .reveal .slides section{visibility:visible!important;display:block!important;position:absolute!important;margin:0!important;padding:0!important;box-sizing:border-box!important;min-height:1px;opacity:1!important;transform-style:flat!important;transform:none!important}html.print-pdf .reveal section.stack{position:relative!important;margin:0!important;padding:0!important;page-break-after:avoid!important;height:auto!important;min-height:auto!important}html.print-pdf .reveal img{box-shadow:none}html.print-pdf .reveal .backgrounds{display:none}html.print-pdf .reveal .slide-background{display:block!important;position:absolute;top:0;left:0;width:100%;height:100%;z-index:auto!important}html.print-pdf .reveal.show-notes{max-width:none;max-height:none}html.print-pdf .reveal .speaker-notes-pdf{display:block;width:100%;height:auto;max-height:none;top:auto;right:auto;bottom:auto;left:auto;z-index:100}html.print-pdf .reveal .speaker-notes-pdf[data-layout=separate-page]{position:relative;color:inherit;background-color:transparent;padding:20px;page-break-after:always;border:0}html.print-pdf .reveal .slide-number-pdf{display:block;position:absolute;font-size:14px}html.print-pdf .aria-status{display:none}@media print{html:not(.print-pdf){background:#fff;width:auto;height:auto;overflow:visible}html:not(.print-pdf) body{background:#fff;font-size:20pt;width:auto;height:auto;border:0;margin:0 5%;padding:0;overflow:visible;float:none!important}html:not(.print-pdf) .controls,html:not(.print-pdf) .fork-reveal,html:not(.print-pdf) .nestedarrow,html:not(.print-pdf) .reveal .backgrounds,html:not(.print-pdf) .reveal .progress,html:not(.print-pdf) .reveal .slide-number,html:not(.print-pdf) .share-reveal,html:not(.print-pdf) .state-background{display:none!important}html:not(.print-pdf) body,html:not(.print-pdf) li,html:not(.print-pdf) p,html:not(.print-pdf) td{font-size:20pt!important;color:#000}html:not(.print-pdf) h1,html:not(.print-pdf) h2,html:not(.print-pdf) h3,html:not(.print-pdf) h4,html:not(.print-pdf) h5,html:not(.print-pdf) h6{color:#000!important;height:auto;line-height:normal;text-align:left;letter-spacing:normal}html:not(.print-pdf) h1{font-size:28pt!important}html:not(.print-pdf) h2{font-size:24pt!important}html:not(.print-pdf) h3{font-size:22pt!important}html:not(.print-pdf) h4{font-size:22pt!important;font-variant:small-caps}html:not(.print-pdf) h5{font-size:21pt!important}html:not(.print-pdf) h6{font-size:20pt!important;font-style:italic}html:not(.print-pdf) a:link,html:not(.print-pdf) a:visited{color:#000!important;font-weight:700;text-decoration:underline}html:not(.print-pdf) div,html:not(.print-pdf) ol,html:not(.print-pdf) p,html:not(.print-pdf) ul{visibility:visible;position:static;width:auto;height:auto;display:block;overflow:visible;margin:0;text-align:left!important}html:not(.print-pdf) .reveal pre,html:not(.print-pdf) .reveal table{margin-left:0;margin-right:0}html:not(.print-pdf) .reveal pre code{padding:20px}html:not(.print-pdf) .reveal blockquote{margin:20px 0}html:not(.print-pdf) .reveal .slides{position:static!important;width:auto!important;height:auto!important;left:0!important;top:0!important;margin-left:0!important;margin-top:0!important;padding:0!important;zoom:1!important;transform:none!important;overflow:visible!important;display:block!important;text-align:left!important;perspective:none;perspective-origin:50% 50%}html:not(.print-pdf) .reveal .slides section{visibility:visible!important;position:static!important;width:auto!important;height:auto!important;display:block!important;overflow:visible!important;left:0!important;top:0!important;margin-left:0!important;margin-top:0!important;padding:60px 20px!important;z-index:auto!important;opacity:1!important;page-break-after:always!important;transform-style:flat!important;transform:none!important;transition:none!important}html:not(.print-pdf) .reveal .slides section.stack{padding:0!important}html:not(.print-pdf) .reveal section:last-of-type{page-break-after:avoid!important}html:not(.print-pdf) .reveal section .fragment{opacity:1!important;visibility:visible!important;transform:none!important}html:not(.print-pdf) .reveal section img{display:block;margin:15px 0;background:#fff;border:1px solid #666;box-shadow:none}html:not(.print-pdf) .reveal section small{font-size:.8em}html:not(.print-pdf) .reveal .hljs{max-height:100%;white-space:pre-wrap;word-wrap:break-word;word-break:break-word;font-size:15pt}html:not(.print-pdf) .reveal .hljs .hljs-ln-numbers{white-space:nowrap}html:not(.print-pdf) .reveal .hljs td{font-size:inherit!important;color:inherit!important}} \ No newline at end of file diff --git a/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.js b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.js new file mode 100644 index 000000000..5227c29a0 --- /dev/null +++ b/core/src/main/resources/META-INF/resources/primefaces-extensions/keynote/lib/reveal.js @@ -0,0 +1,8 @@ +/*! +* reveal.js 4.2.0 +* https://revealjs.com +* MIT licensed +* +* Copyright (C) 2011-2021 Hakim El Hattab, https://hakim.se +*/ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Reveal=t()}(this,(function(){"use strict";var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},t=function(e){return e&&e.Math==Math&&e},n=t("object"==typeof globalThis&&globalThis)||t("object"==typeof window&&window)||t("object"==typeof self&&self)||t("object"==typeof e&&e)||function(){return this}()||Function("return this")(),i={},r=function(e){try{return!!e()}catch(e){return!0}},a=!r((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]})),o={},s={}.propertyIsEnumerable,l=Object.getOwnPropertyDescriptor,c=l&&!s.call({1:2},1);o.f=c?function(e){var t=l(this,e);return!!t&&t.enumerable}:s;var u=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}},d={}.toString,h=function(e){return d.call(e).slice(8,-1)},f=h,v="".split,g=r((function(){return!Object("z").propertyIsEnumerable(0)}))?function(e){return"String"==f(e)?v.call(e,""):Object(e)}:Object,p=function(e){if(null==e)throw TypeError("Can't call method on "+e);return e},m=g,y=p,b=function(e){return m(y(e))},w=function(e){return"object"==typeof e?null!==e:"function"==typeof e},S=w,E=function(e,t){if(!S(e))return e;var n,i;if(t&&"function"==typeof(n=e.toString)&&!S(i=n.call(e)))return i;if("function"==typeof(n=e.valueOf)&&!S(i=n.call(e)))return i;if(!t&&"function"==typeof(n=e.toString)&&!S(i=n.call(e)))return i;throw TypeError("Can't convert object to primitive value")},k=p,A=function(e){return Object(k(e))},R=A,x={}.hasOwnProperty,L=function(e,t){return x.call(R(e),t)},P=w,C=n.document,N=P(C)&&P(C.createElement),I=function(e){return N?C.createElement(e):{}},M=I,T=!a&&!r((function(){return 7!=Object.defineProperty(M("div"),"a",{get:function(){return 7}}).a})),O=a,D=o,j=u,F=b,z=E,H=L,U=T,B=Object.getOwnPropertyDescriptor;i.f=O?B:function(e,t){if(e=F(e),t=z(t,!0),U)try{return B(e,t)}catch(e){}if(H(e,t))return j(!D.f.call(e,t),e[t])};var _={},q=w,W=function(e){if(!q(e))throw TypeError(String(e)+" is not an object");return e},V=a,K=T,Y=W,$=E,X=Object.defineProperty;_.f=V?X:function(e,t,n){if(Y(e),t=$(t,!0),Y(n),K)try{return X(e,t,n)}catch(e){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(e[t]=n.value),e};var G=_,J=u,Q=a?function(e,t,n){return G.f(e,t,J(1,n))}:function(e,t,n){return e[t]=n,e},Z={exports:{}},ee=n,te=Q,ne=function(e,t){try{te(ee,e,t)}catch(n){ee[e]=t}return t},ie=ne,re="__core-js_shared__",ae=n[re]||ie(re,{}),oe=ae,se=Function.toString;"function"!=typeof oe.inspectSource&&(oe.inspectSource=function(e){return se.call(e)});var le=oe.inspectSource,ce=le,ue=n.WeakMap,de="function"==typeof ue&&/native code/.test(ce(ue)),he={exports:{}},fe=ae;(he.exports=function(e,t){return fe[e]||(fe[e]=void 0!==t?t:{})})("versions",[]).push({version:"3.12.1",mode:"global",copyright:"© 2021 Denis Pushkarev (zloirock.ru)"});var ve,ge,pe,me=0,ye=Math.random(),be=function(e){return"Symbol("+String(void 0===e?"":e)+")_"+(++me+ye).toString(36)},we=he.exports,Se=be,Ee=we("keys"),ke=function(e){return Ee[e]||(Ee[e]=Se(e))},Ae={},Re=de,xe=w,Le=Q,Pe=L,Ce=ae,Ne=ke,Ie=Ae,Me="Object already initialized",Te=n.WeakMap;if(Re||Ce.state){var Oe=Ce.state||(Ce.state=new Te),De=Oe.get,je=Oe.has,Fe=Oe.set;ve=function(e,t){if(je.call(Oe,e))throw new TypeError(Me);return t.facade=e,Fe.call(Oe,e,t),t},ge=function(e){return De.call(Oe,e)||{}},pe=function(e){return je.call(Oe,e)}}else{var ze=Ne("state");Ie[ze]=!0,ve=function(e,t){if(Pe(e,ze))throw new TypeError(Me);return t.facade=e,Le(e,ze,t),t},ge=function(e){return Pe(e,ze)?e[ze]:{}},pe=function(e){return Pe(e,ze)}}var He={set:ve,get:ge,has:pe,enforce:function(e){return pe(e)?ge(e):ve(e,{})},getterFor:function(e){return function(t){var n;if(!xe(t)||(n=ge(t)).type!==e)throw TypeError("Incompatible receiver, "+e+" required");return n}}},Ue=n,Be=Q,_e=L,qe=ne,We=le,Ve=He.get,Ke=He.enforce,Ye=String(String).split("String");(Z.exports=function(e,t,n,i){var r,a=!!i&&!!i.unsafe,o=!!i&&!!i.enumerable,s=!!i&&!!i.noTargetGet;"function"==typeof n&&("string"!=typeof t||_e(n,"name")||Be(n,"name",t),(r=Ke(n)).source||(r.source=Ye.join("string"==typeof t?t:""))),e!==Ue?(a?!s&&e[t]&&(o=!0):delete e[t],o?e[t]=n:Be(e,t,n)):o?e[t]=n:qe(t,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&Ve(this).source||We(this)}));var $e=n,Xe=$e,Ge=n,Je=function(e){return"function"==typeof e?e:void 0},Qe=function(e,t){return arguments.length<2?Je(Xe[e])||Je(Ge[e]):Xe[e]&&Xe[e][t]||Ge[e]&&Ge[e][t]},Ze={},et=Math.ceil,tt=Math.floor,nt=function(e){return isNaN(e=+e)?0:(e>0?tt:et)(e)},it=nt,rt=Math.min,at=function(e){return e>0?rt(it(e),9007199254740991):0},ot=nt,st=Math.max,lt=Math.min,ct=function(e,t){var n=ot(e);return n<0?st(n+t,0):lt(n,t)},ut=b,dt=at,ht=ct,ft=function(e){return function(t,n,i){var r,a=ut(t),o=dt(a.length),s=ht(i,o);if(e&&n!=n){for(;o>s;)if((r=a[s++])!=r)return!0}else for(;o>s;s++)if((e||s in a)&&a[s]===n)return e||s||0;return!e&&-1}},vt={includes:ft(!0),indexOf:ft(!1)},gt=L,pt=b,mt=vt.indexOf,yt=Ae,bt=function(e,t){var n,i=pt(e),r=0,a=[];for(n in i)!gt(yt,n)&>(i,n)&&a.push(n);for(;t.length>r;)gt(i,n=t[r++])&&(~mt(a,n)||a.push(n));return a},wt=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],St=bt,Et=wt.concat("length","prototype");Ze.f=Object.getOwnPropertyNames||function(e){return St(e,Et)};var kt={};kt.f=Object.getOwnPropertySymbols;var At=Ze,Rt=kt,xt=W,Lt=Qe("Reflect","ownKeys")||function(e){var t=At.f(xt(e)),n=Rt.f;return n?t.concat(n(e)):t},Pt=L,Ct=Lt,Nt=i,It=_,Mt=function(e,t){for(var n=Ct(t),i=It.f,r=Nt.f,a=0;ar;)for(var s,l=an(arguments[r++]),c=a?en(l).concat(a(l)):en(l),u=c.length,d=0;u>d;)s=c[d++],Qt&&!o.call(l,s)||(n[s]=l[s]);return n}:on;$t({target:"Object",stat:!0,forced:Object.assign!==ln},{assign:ln});var cn,un,dn=function(e){if("function"!=typeof e)throw TypeError(String(e)+" is not a function");return e},hn=dn,fn=function(e,t,n){if(hn(e),void 0===t)return e;switch(n){case 0:return function(){return e.call(t)};case 1:return function(n){return e.call(t,n)};case 2:return function(n,i){return e.call(t,n,i)};case 3:return function(n,i,r){return e.call(t,n,i,r)}}return function(){return e.apply(t,arguments)}},vn=h,gn=Array.isArray||function(e){return"Array"==vn(e)},pn=Qe("navigator","userAgent")||"",mn=pn,yn=n.process,bn=yn&&yn.versions,wn=bn&&bn.v8;wn?un=(cn=wn.split("."))[0]<4?1:cn[0]+cn[1]:mn&&(!(cn=mn.match(/Edge\/(\d+)/))||cn[1]>=74)&&(cn=mn.match(/Chrome\/(\d+)/))&&(un=cn[1]);var Sn=un&&+un,En=Sn,kn=r,An=!!Object.getOwnPropertySymbols&&!kn((function(){return!String(Symbol())||!Symbol.sham&&En&&En<41})),Rn=An&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,xn=n,Ln=he.exports,Pn=L,Cn=be,Nn=An,In=Rn,Mn=Ln("wks"),Tn=xn.Symbol,On=In?Tn:Tn&&Tn.withoutSetter||Cn,Dn=function(e){return Pn(Mn,e)&&(Nn||"string"==typeof Mn[e])||(Nn&&Pn(Tn,e)?Mn[e]=Tn[e]:Mn[e]=On("Symbol."+e)),Mn[e]},jn=w,Fn=gn,zn=Dn("species"),Hn=function(e,t){var n;return Fn(e)&&("function"!=typeof(n=e.constructor)||n!==Array&&!Fn(n.prototype)?jn(n)&&null===(n=n[zn])&&(n=void 0):n=void 0),new(void 0===n?Array:n)(0===t?0:t)},Un=fn,Bn=g,_n=A,qn=at,Wn=Hn,Vn=[].push,Kn=function(e){var t=1==e,n=2==e,i=3==e,r=4==e,a=6==e,o=7==e,s=5==e||a;return function(l,c,u,d){for(var h,f,v=_n(l),g=Bn(v),p=Un(c,u,3),m=qn(g.length),y=0,b=d||Wn,w=t?b(l,m):n||o?b(l,0):void 0;m>y;y++)if((s||y in g)&&(f=p(h=g[y],y,v),e))if(t)w[y]=f;else if(f)switch(e){case 3:return!0;case 5:return h;case 6:return y;case 2:Vn.call(w,h)}else switch(e){case 4:return!1;case 7:Vn.call(w,h)}return a?-1:i||r?r:w}},Yn={forEach:Kn(0),map:Kn(1),filter:Kn(2),some:Kn(3),every:Kn(4),find:Kn(5),findIndex:Kn(6),filterOut:Kn(7)},$n=r,Xn=Sn,Gn=Dn("species"),Jn=function(e){return Xn>=51||!$n((function(){var t=[];return(t.constructor={})[Gn]=function(){return{foo:1}},1!==t[e](Boolean).foo}))},Qn=Yn.map;$t({target:"Array",proto:!0,forced:!Jn("map")},{map:function(e){return Qn(this,e,arguments.length>1?arguments[1]:void 0)}});var Zn=E,ei=_,ti=u,ni=function(e,t,n){var i=Zn(t);i in e?ei.f(e,i,ti(0,n)):e[i]=n},ii=$t,ri=r,ai=gn,oi=w,si=A,li=at,ci=ni,ui=Hn,di=Jn,hi=Sn,fi=Dn("isConcatSpreadable"),vi=9007199254740991,gi="Maximum allowed index exceeded",pi=hi>=51||!ri((function(){var e=[];return e[fi]=!1,e.concat()[0]!==e})),mi=di("concat"),yi=function(e){if(!oi(e))return!1;var t=e[fi];return void 0!==t?!!t:ai(e)};function bi(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(e);t&&(i=i.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,i)}return n}function wi(e){for(var t=1;te.length)&&(t=e.length);for(var n=0,i=new Array(t);nvi)throw TypeError(gi);for(n=0;n=vi)throw TypeError(gi);ci(s,l++,a)}return s.length=l,s}});var Ci={};Ci[Dn("toStringTag")]="z";var Ni="[object z]"===String(Ci),Ii=Ni,Mi=h,Ti=Dn("toStringTag"),Oi="Arguments"==Mi(function(){return arguments}()),Di=Ii?Mi:function(e){var t,n,i;return void 0===e?"Undefined":null===e?"Null":"string"==typeof(n=function(e,t){try{return e[t]}catch(e){}}(t=Object(e),Ti))?n:Oi?Mi(t):"Object"==(i=Mi(t))&&"function"==typeof t.callee?"Arguments":i},ji=Di,Fi=Ni?{}.toString:function(){return"[object "+ji(this)+"]"},zi=Ni,Hi=Z.exports,Ui=Fi;zi||Hi(Object.prototype,"toString",Ui,{unsafe:!0});var Bi=n.Promise,_i=Z.exports,qi=w,Wi=W,Vi=function(e){if(!qi(e)&&null!==e)throw TypeError("Can't set "+String(e)+" as a prototype");return e},Ki=Object.setPrototypeOf||("__proto__"in{}?function(){var e,t=!1,n={};try{(e=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set).call(n,[]),t=n instanceof Array}catch(e){}return function(n,i){return Wi(n),Vi(i),t?e.call(n,i):n.__proto__=i,n}}():void 0),Yi=_.f,$i=L,Xi=Dn("toStringTag"),Gi=function(e,t,n){e&&!$i(e=n?e:e.prototype,Xi)&&Yi(e,Xi,{configurable:!0,value:t})},Ji=Qe,Qi=_,Zi=a,er=Dn("species"),tr={},nr=tr,ir=Dn("iterator"),rr=Array.prototype,ar=function(e){return void 0!==e&&(nr.Array===e||rr[ir]===e)},or=Di,sr=tr,lr=Dn("iterator"),cr=function(e){if(null!=e)return e[lr]||e["@@iterator"]||sr[or(e)]},ur=W,dr=function(e){var t=e.return;if(void 0!==t)return ur(t.call(e)).value},hr=W,fr=ar,vr=at,gr=fn,pr=cr,mr=dr,yr=function(e,t){this.stopped=e,this.result=t},br=Dn("iterator"),wr=!1;try{var Sr=0,Er={next:function(){return{done:!!Sr++}},return:function(){wr=!0}};Er[br]=function(){return this},Array.from(Er,(function(){throw 2}))}catch(e){}var kr,Ar,Rr,xr=function(e,t){if(!t&&!wr)return!1;var n=!1;try{var i={};i[br]=function(){return{next:function(){return{done:n=!0}}}},e(i)}catch(e){}return n},Lr=W,Pr=dn,Cr=Dn("species"),Nr=function(e,t){var n,i=Lr(e).constructor;return void 0===i||null==(n=Lr(i)[Cr])?t:Pr(n)},Ir=Qe("document","documentElement"),Mr=/(?:iphone|ipod|ipad).*applewebkit/i.test(pn),Tr="process"==h(n.process),Or=n,Dr=r,jr=fn,Fr=Ir,zr=I,Hr=Mr,Ur=Tr,Br=Or.location,_r=Or.setImmediate,qr=Or.clearImmediate,Wr=Or.process,Vr=Or.MessageChannel,Kr=Or.Dispatch,Yr=0,$r={},Xr="onreadystatechange",Gr=function(e){if($r.hasOwnProperty(e)){var t=$r[e];delete $r[e],t()}},Jr=function(e){return function(){Gr(e)}},Qr=function(e){Gr(e.data)},Zr=function(e){Or.postMessage(e+"",Br.protocol+"//"+Br.host)};_r&&qr||(_r=function(e){for(var t=[],n=1;arguments.length>n;)t.push(arguments[n++]);return $r[++Yr]=function(){("function"==typeof e?e:Function(e)).apply(void 0,t)},kr(Yr),Yr},qr=function(e){delete $r[e]},Ur?kr=function(e){Wr.nextTick(Jr(e))}:Kr&&Kr.now?kr=function(e){Kr.now(Jr(e))}:Vr&&!Hr?(Rr=(Ar=new Vr).port2,Ar.port1.onmessage=Qr,kr=jr(Rr.postMessage,Rr,1)):Or.addEventListener&&"function"==typeof postMessage&&!Or.importScripts&&Br&&"file:"!==Br.protocol&&!Dr(Zr)?(kr=Zr,Or.addEventListener("message",Qr,!1)):kr=Xr in zr("script")?function(e){Fr.appendChild(zr("script")).onreadystatechange=function(){Fr.removeChild(this),Gr(e)}}:function(e){setTimeout(Jr(e),0)});var ea,ta,na,ia,ra,aa,oa,sa,la={set:_r,clear:qr},ca=/web0s(?!.*chrome)/i.test(pn),ua=n,da=i.f,ha=la.set,fa=Mr,va=ca,ga=Tr,pa=ua.MutationObserver||ua.WebKitMutationObserver,ma=ua.document,ya=ua.process,ba=ua.Promise,wa=da(ua,"queueMicrotask"),Sa=wa&&wa.value;Sa||(ea=function(){var e,t;for(ga&&(e=ya.domain)&&e.exit();ta;){t=ta.fn,ta=ta.next;try{t()}catch(e){throw ta?ia():na=void 0,e}}na=void 0,e&&e.enter()},fa||ga||va||!pa||!ma?ba&&ba.resolve?((oa=ba.resolve(void 0)).constructor=ba,sa=oa.then,ia=function(){sa.call(oa,ea)}):ia=ga?function(){ya.nextTick(ea)}:function(){ha.call(ua,ea)}:(ra=!0,aa=ma.createTextNode(""),new pa(ea).observe(aa,{characterData:!0}),ia=function(){aa.data=ra=!ra}));var Ea=Sa||function(e){var t={fn:e,next:void 0};na&&(na.next=t),ta||(ta=t,ia()),na=t},ka={},Aa=dn,Ra=function(e){var t,n;this.promise=new e((function(e,i){if(void 0!==t||void 0!==n)throw TypeError("Bad Promise constructor");t=e,n=i})),this.resolve=Aa(t),this.reject=Aa(n)};ka.f=function(e){return new Ra(e)};var xa,La,Pa,Ca,Na=W,Ia=w,Ma=ka,Ta=n,Oa="object"==typeof window,Da=$t,ja=n,Fa=Qe,za=Bi,Ha=Z.exports,Ua=function(e,t,n){for(var i in t)_i(e,i,t[i],n);return e},Ba=Ki,_a=Gi,qa=function(e){var t=Ji(e),n=Qi.f;Zi&&t&&!t[er]&&n(t,er,{configurable:!0,get:function(){return this}})},Wa=w,Va=dn,Ka=function(e,t,n){if(!(e instanceof t))throw TypeError("Incorrect "+(n?n+" ":"")+"invocation");return e},Ya=le,$a=function(e,t,n){var i,r,a,o,s,l,c,u=n&&n.that,d=!(!n||!n.AS_ENTRIES),h=!(!n||!n.IS_ITERATOR),f=!(!n||!n.INTERRUPTED),v=gr(t,u,1+d+f),g=function(e){return i&&mr(i),new yr(!0,e)},p=function(e){return d?(hr(e),f?v(e[0],e[1],g):v(e[0],e[1])):f?v(e,g):v(e)};if(h)i=e;else{if("function"!=typeof(r=pr(e)))throw TypeError("Target is not iterable");if(fr(r)){for(a=0,o=vr(e.length);o>a;a++)if((s=p(e[a]))&&s instanceof yr)return s;return new yr(!1)}i=r.call(e)}for(l=i.next;!(c=l.call(i)).done;){try{s=p(c.value)}catch(e){throw mr(i),e}if("object"==typeof s&&s&&s instanceof yr)return s}return new yr(!1)},Xa=xr,Ga=Nr,Ja=la.set,Qa=Ea,Za=function(e,t){if(Na(e),Ia(t)&&t.constructor===e)return t;var n=Ma.f(e);return(0,n.resolve)(t),n.promise},eo=function(e,t){var n=Ta.console;n&&n.error&&(1===arguments.length?n.error(e):n.error(e,t))},to=ka,no=function(e){try{return{error:!1,value:e()}}catch(e){return{error:!0,value:e}}},io=He,ro=Ut,ao=Oa,oo=Tr,so=Sn,lo=Dn("species"),co="Promise",uo=io.get,ho=io.set,fo=io.getterFor(co),vo=za&&za.prototype,go=za,po=vo,mo=ja.TypeError,yo=ja.document,bo=ja.process,wo=to.f,So=wo,Eo=!!(yo&&yo.createEvent&&ja.dispatchEvent),ko="function"==typeof PromiseRejectionEvent,Ao="unhandledrejection",Ro=!1,xo=ro(co,(function(){var e=Ya(go)!==String(go);if(!e&&66===so)return!0;if(so>=51&&/native code/.test(go))return!1;var t=new go((function(e){e(1)})),n=function(e){e((function(){}),(function(){}))};return(t.constructor={})[lo]=n,!(Ro=t.then((function(){}))instanceof n)||!e&&ao&&!ko})),Lo=xo||!Xa((function(e){go.all(e).catch((function(){}))})),Po=function(e){var t;return!(!Wa(e)||"function"!=typeof(t=e.then))&&t},Co=function(e,t){if(!e.notified){e.notified=!0;var n=e.reactions;Qa((function(){for(var i=e.value,r=1==e.state,a=0;n.length>a;){var o,s,l,c=n[a++],u=r?c.ok:c.fail,d=c.resolve,h=c.reject,f=c.domain;try{u?(r||(2===e.rejection&&To(e),e.rejection=1),!0===u?o=i:(f&&f.enter(),o=u(i),f&&(f.exit(),l=!0)),o===c.promise?h(mo("Promise-chain cycle")):(s=Po(o))?s.call(o,d,h):d(o)):h(i)}catch(e){f&&!l&&f.exit(),h(e)}}e.reactions=[],e.notified=!1,t&&!e.rejection&&Io(e)}))}},No=function(e,t,n){var i,r;Eo?((i=yo.createEvent("Event")).promise=t,i.reason=n,i.initEvent(e,!1,!0),ja.dispatchEvent(i)):i={promise:t,reason:n},!ko&&(r=ja["on"+e])?r(i):e===Ao&&eo("Unhandled promise rejection",n)},Io=function(e){Ja.call(ja,(function(){var t,n=e.facade,i=e.value;if(Mo(e)&&(t=no((function(){oo?bo.emit("unhandledRejection",i,n):No(Ao,n,i)})),e.rejection=oo||Mo(e)?2:1,t.error))throw t.value}))},Mo=function(e){return 1!==e.rejection&&!e.parent},To=function(e){Ja.call(ja,(function(){var t=e.facade;oo?bo.emit("rejectionHandled",t):No("rejectionhandled",t,e.value)}))},Oo=function(e,t,n){return function(i){e(t,i,n)}},Do=function(e,t,n){e.done||(e.done=!0,n&&(e=n),e.value=t,e.state=2,Co(e,!0))},jo=function(e,t,n){if(!e.done){e.done=!0,n&&(e=n);try{if(e.facade===t)throw mo("Promise can't be resolved itself");var i=Po(t);i?Qa((function(){var n={done:!1};try{i.call(t,Oo(jo,n,e),Oo(Do,n,e))}catch(t){Do(n,t,e)}})):(e.value=t,e.state=1,Co(e,!1))}catch(t){Do({done:!1},t,e)}}};if(xo&&(po=(go=function(e){Ka(this,go,co),Va(e),xa.call(this);var t=uo(this);try{e(Oo(jo,t),Oo(Do,t))}catch(e){Do(t,e)}}).prototype,(xa=function(e){ho(this,{type:co,done:!1,notified:!1,parent:!1,reactions:[],rejection:!1,state:0,value:void 0})}).prototype=Ua(po,{then:function(e,t){var n=fo(this),i=wo(Ga(this,go));return i.ok="function"!=typeof e||e,i.fail="function"==typeof t&&t,i.domain=oo?bo.domain:void 0,n.parent=!0,n.reactions.push(i),0!=n.state&&Co(n,!1),i.promise},catch:function(e){return this.then(void 0,e)}}),La=function(){var e=new xa,t=uo(e);this.promise=e,this.resolve=Oo(jo,t),this.reject=Oo(Do,t)},to.f=wo=function(e){return e===go||e===Pa?new La(e):So(e)},"function"==typeof za&&vo!==Object.prototype)){Ca=vo.then,Ro||(Ha(vo,"then",(function(e,t){var n=this;return new go((function(e,t){Ca.call(n,e,t)})).then(e,t)}),{unsafe:!0}),Ha(vo,"catch",po.catch,{unsafe:!0}));try{delete vo.constructor}catch(e){}Ba&&Ba(vo,po)}Da({global:!0,wrap:!0,forced:xo},{Promise:go}),_a(go,co,!1),qa(co),Pa=Fa(co),Da({target:co,stat:!0,forced:xo},{reject:function(e){var t=wo(this);return t.reject.call(void 0,e),t.promise}}),Da({target:co,stat:!0,forced:xo},{resolve:function(e){return Za(this,e)}}),Da({target:co,stat:!0,forced:Lo},{all:function(e){var t=this,n=wo(t),i=n.resolve,r=n.reject,a=no((function(){var n=Va(t.resolve),a=[],o=0,s=1;$a(e,(function(e){var l=o++,c=!1;a.push(void 0),s++,n.call(t,e).then((function(e){c||(c=!0,a[l]=e,--s||i(a))}),r)})),--s||i(a)}));return a.error&&r(a.value),n.promise},race:function(e){var t=this,n=wo(t),i=n.reject,r=no((function(){var r=Va(t.resolve);$a(e,(function(e){r.call(t,e).then(n.resolve,i)}))}));return r.error&&i(r.value),n.promise}});var Fo=r,zo=function(e,t){var n=[][e];return!!n&&Fo((function(){n.call(null,t||function(){throw 1},1)}))},Ho=Yn.forEach,Uo=n,Bo={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},_o=zo("forEach")?[].forEach:function(e){return Ho(this,e,arguments.length>1?arguments[1]:void 0)},qo=Q;for(var Wo in Bo){var Vo=Uo[Wo],Ko=Vo&&Vo.prototype;if(Ko&&Ko.forEach!==_o)try{qo(Ko,"forEach",_o)}catch(e){Ko.forEach=_o}}var Yo=W,$o=dr,Xo=fn,Go=A,Jo=function(e,t,n,i){try{return i?t(Yo(n)[0],n[1]):t(n)}catch(t){throw $o(e),t}},Qo=ar,Zo=at,es=ni,ts=cr,ns=function(e){var t,n,i,r,a,o,s=Go(e),l="function"==typeof this?this:Array,c=arguments.length,u=c>1?arguments[1]:void 0,d=void 0!==u,h=ts(s),f=0;if(d&&(u=Xo(u,c>2?arguments[2]:void 0,2)),null==h||l==Array&&Qo(h))for(n=new l(t=Zo(s.length));t>f;f++)o=d?u(s[f],f):s[f],es(n,f,o);else for(a=(r=h.call(s)).next,n=new l;!(i=a.call(r)).done;f++)o=d?Jo(r,u,[i.value,f],!0):i.value,es(n,f,o);return n.length=f,n};$t({target:"Array",stat:!0,forced:!xr((function(e){Array.from(e)}))},{from:ns});var is,rs,as,os=nt,ss=p,ls=function(e){return function(t,n){var i,r,a=String(ss(t)),o=os(n),s=a.length;return o<0||o>=s?e?"":void 0:(i=a.charCodeAt(o))<55296||i>56319||o+1===s||(r=a.charCodeAt(o+1))<56320||r>57343?e?a.charAt(o):i:e?a.slice(o,o+2):r-56320+(i-55296<<10)+65536}},cs={codeAt:ls(!1),charAt:ls(!0)},us=!r((function(){function e(){}return e.prototype.constructor=null,Object.getPrototypeOf(new e)!==e.prototype})),ds=L,hs=A,fs=us,vs=ke("IE_PROTO"),gs=Object.prototype,ps=fs?Object.getPrototypeOf:function(e){return e=hs(e),ds(e,vs)?e[vs]:"function"==typeof e.constructor&&e instanceof e.constructor?e.constructor.prototype:e instanceof Object?gs:null},ms=r,ys=ps,bs=Q,ws=L,Ss=Dn("iterator"),Es=!1;[].keys&&("next"in(as=[].keys())?(rs=ys(ys(as)))!==Object.prototype&&(is=rs):Es=!0),(null==is||ms((function(){var e={};return is[Ss].call(e)!==e})))&&(is={}),ws(is,Ss)||bs(is,Ss,(function(){return this}));var ks,As={IteratorPrototype:is,BUGGY_SAFARI_ITERATORS:Es},Rs=_,xs=W,Ls=Jt,Ps=a?Object.defineProperties:function(e,t){xs(e);for(var n,i=Ls(t),r=i.length,a=0;r>a;)Rs.f(e,n=i[a++],t[n]);return e},Cs=W,Ns=Ps,Is=wt,Ms=Ae,Ts=Ir,Os=I,Ds=ke("IE_PROTO"),js=function(){},Fs=function(e){return"