├── bootstrap-4.0.0-dist ├── css │ ├── bootstrap-grid.css │ ├── bootstrap-grid.css.map │ ├── bootstrap-grid.min.css │ ├── bootstrap-grid.min.css.map │ ├── bootstrap-reboot.css │ ├── bootstrap-reboot.css.map │ ├── bootstrap-reboot.min.css │ ├── bootstrap-reboot.min.css.map │ ├── bootstrap.css │ ├── bootstrap.css.map │ ├── bootstrap.min.css │ └── bootstrap.min.css.map └── js │ ├── bootstrap.bundle.js │ ├── bootstrap.bundle.js.map │ ├── bootstrap.bundle.min.js │ ├── bootstrap.bundle.min.js.map │ ├── bootstrap.js │ ├── bootstrap.js.map │ ├── bootstrap.min.js │ └── bootstrap.min.js.map ├── index.html ├── me.png ├── node_modules ├── .package-lock.json ├── @popperjs │ └── core │ │ ├── LICENSE.md │ │ ├── README.md │ │ ├── dist │ │ ├── cjs │ │ │ ├── enums.js │ │ │ ├── enums.js.flow │ │ │ ├── enums.js.map │ │ │ ├── popper-base.js │ │ │ ├── popper-base.js.flow │ │ │ ├── popper-base.js.map │ │ │ ├── popper-lite.js │ │ │ ├── popper-lite.js.flow │ │ │ ├── popper-lite.js.map │ │ │ ├── popper.js │ │ │ ├── popper.js.flow │ │ │ └── popper.js.map │ │ ├── esm │ │ │ ├── createPopper.js │ │ │ ├── dom-utils │ │ │ │ ├── contains.js │ │ │ │ ├── getBoundingClientRect.js │ │ │ │ ├── getClippingRect.js │ │ │ │ ├── getCompositeRect.js │ │ │ │ ├── getComputedStyle.js │ │ │ │ ├── getDocumentElement.js │ │ │ │ ├── getDocumentRect.js │ │ │ │ ├── getHTMLElementScroll.js │ │ │ │ ├── getLayoutRect.js │ │ │ │ ├── getNodeName.js │ │ │ │ ├── getNodeScroll.js │ │ │ │ ├── getOffsetParent.js │ │ │ │ ├── getParentNode.js │ │ │ │ ├── getScrollParent.js │ │ │ │ ├── getViewportRect.js │ │ │ │ ├── getWindow.js │ │ │ │ ├── getWindowScroll.js │ │ │ │ ├── getWindowScrollBarX.js │ │ │ │ ├── instanceOf.js │ │ │ │ ├── isLayoutViewport.js │ │ │ │ ├── isScrollParent.js │ │ │ │ ├── isTableElement.js │ │ │ │ └── listScrollParents.js │ │ │ ├── enums.js │ │ │ ├── index.js │ │ │ ├── modifiers │ │ │ │ ├── applyStyles.js │ │ │ │ ├── arrow.js │ │ │ │ ├── computeStyles.js │ │ │ │ ├── eventListeners.js │ │ │ │ ├── flip.js │ │ │ │ ├── hide.js │ │ │ │ ├── index.js │ │ │ │ ├── offset.js │ │ │ │ ├── popperOffsets.js │ │ │ │ └── preventOverflow.js │ │ │ ├── popper-base.js │ │ │ ├── popper-lite.js │ │ │ ├── popper.js │ │ │ ├── types.js │ │ │ └── utils │ │ │ │ ├── computeAutoPlacement.js │ │ │ │ ├── computeOffsets.js │ │ │ │ ├── debounce.js │ │ │ │ ├── detectOverflow.js │ │ │ │ ├── expandToHashMap.js │ │ │ │ ├── getAltAxis.js │ │ │ │ ├── getAltLen.js │ │ │ │ ├── getBasePlacement.js │ │ │ │ ├── getFreshSideObject.js │ │ │ │ ├── getMainAxisFromPlacement.js │ │ │ │ ├── getOppositePlacement.js │ │ │ │ ├── getOppositeVariationPlacement.js │ │ │ │ ├── getVariation.js │ │ │ │ ├── math.js │ │ │ │ ├── mergeByName.js │ │ │ │ ├── mergePaddingObject.js │ │ │ │ ├── orderModifiers.js │ │ │ │ ├── rectToClientRect.js │ │ │ │ ├── uniqueBy.js │ │ │ │ ├── userAgent.js │ │ │ │ └── within.js │ │ └── umd │ │ │ ├── enums.js │ │ │ ├── enums.js.map │ │ │ ├── enums.min.js │ │ │ ├── enums.min.js.flow │ │ │ ├── enums.min.js.map │ │ │ ├── popper-base.js │ │ │ ├── popper-base.js.map │ │ │ ├── popper-base.min.js │ │ │ ├── popper-base.min.js.flow │ │ │ ├── popper-base.min.js.map │ │ │ ├── popper-lite.js │ │ │ ├── popper-lite.js.map │ │ │ ├── popper-lite.min.js │ │ │ ├── popper-lite.min.js.flow │ │ │ ├── popper-lite.min.js.map │ │ │ ├── popper.js │ │ │ ├── popper.js.map │ │ │ ├── popper.min.js │ │ │ ├── popper.min.js.flow │ │ │ └── popper.min.js.map │ │ ├── index.d.ts │ │ ├── lib │ │ ├── createPopper.d.ts │ │ ├── createPopper.js │ │ ├── createPopper.js.flow │ │ ├── dom-utils │ │ │ ├── contains.d.ts │ │ │ ├── contains.js │ │ │ ├── contains.js.flow │ │ │ ├── getBoundingClientRect.d.ts │ │ │ ├── getBoundingClientRect.js │ │ │ ├── getBoundingClientRect.js.flow │ │ │ ├── getClippingRect.d.ts │ │ │ ├── getClippingRect.js │ │ │ ├── getClippingRect.js.flow │ │ │ ├── getCompositeRect.d.ts │ │ │ ├── getCompositeRect.js │ │ │ ├── getCompositeRect.js.flow │ │ │ ├── getComputedStyle.d.ts │ │ │ ├── getComputedStyle.js │ │ │ ├── getComputedStyle.js.flow │ │ │ ├── getDocumentElement.d.ts │ │ │ ├── getDocumentElement.js │ │ │ ├── getDocumentElement.js.flow │ │ │ ├── getDocumentRect.d.ts │ │ │ ├── getDocumentRect.js │ │ │ ├── getDocumentRect.js.flow │ │ │ ├── getHTMLElementScroll.d.ts │ │ │ ├── getHTMLElementScroll.js │ │ │ ├── getHTMLElementScroll.js.flow │ │ │ ├── getLayoutRect.d.ts │ │ │ ├── getLayoutRect.js │ │ │ ├── getLayoutRect.js.flow │ │ │ ├── getNodeName.d.ts │ │ │ ├── getNodeName.js │ │ │ ├── getNodeName.js.flow │ │ │ ├── getNodeScroll.d.ts │ │ │ ├── getNodeScroll.js │ │ │ ├── getNodeScroll.js.flow │ │ │ ├── getOffsetParent.d.ts │ │ │ ├── getOffsetParent.js │ │ │ ├── getOffsetParent.js.flow │ │ │ ├── getParentNode.d.ts │ │ │ ├── getParentNode.js │ │ │ ├── getParentNode.js.flow │ │ │ ├── getScrollParent.d.ts │ │ │ ├── getScrollParent.js │ │ │ ├── getScrollParent.js.flow │ │ │ ├── getViewportRect.d.ts │ │ │ ├── getViewportRect.js │ │ │ ├── getViewportRect.js.flow │ │ │ ├── getWindow.d.ts │ │ │ ├── getWindow.js │ │ │ ├── getWindow.js.flow │ │ │ ├── getWindowScroll.d.ts │ │ │ ├── getWindowScroll.js │ │ │ ├── getWindowScroll.js.flow │ │ │ ├── getWindowScrollBarX.d.ts │ │ │ ├── getWindowScrollBarX.js │ │ │ ├── getWindowScrollBarX.js.flow │ │ │ ├── instanceOf.d.ts │ │ │ ├── instanceOf.js │ │ │ ├── instanceOf.js.flow │ │ │ ├── isLayoutViewport.d.ts │ │ │ ├── isLayoutViewport.js │ │ │ ├── isLayoutViewport.js.flow │ │ │ ├── isScrollParent.d.ts │ │ │ ├── isScrollParent.js │ │ │ ├── isScrollParent.js.flow │ │ │ ├── isTableElement.d.ts │ │ │ ├── isTableElement.js │ │ │ ├── isTableElement.js.flow │ │ │ ├── listScrollParents.d.ts │ │ │ ├── listScrollParents.js │ │ │ └── listScrollParents.js.flow │ │ ├── enums.d.ts │ │ ├── enums.js │ │ ├── enums.js.flow │ │ ├── index.d.ts │ │ ├── index.js │ │ ├── index.js.flow │ │ ├── modifiers │ │ │ ├── applyStyles.d.ts │ │ │ ├── applyStyles.js │ │ │ ├── applyStyles.js.flow │ │ │ ├── arrow.d.ts │ │ │ ├── arrow.js │ │ │ ├── arrow.js.flow │ │ │ ├── computeStyles.d.ts │ │ │ ├── computeStyles.js │ │ │ ├── computeStyles.js.flow │ │ │ ├── eventListeners.d.ts │ │ │ ├── eventListeners.js │ │ │ ├── eventListeners.js.flow │ │ │ ├── flip.d.ts │ │ │ ├── flip.js │ │ │ ├── flip.js.flow │ │ │ ├── hide.d.ts │ │ │ ├── hide.js │ │ │ ├── hide.js.flow │ │ │ ├── index.d.ts │ │ │ ├── index.js │ │ │ ├── index.js.flow │ │ │ ├── offset.d.ts │ │ │ ├── offset.js │ │ │ ├── offset.js.flow │ │ │ ├── popperOffsets.d.ts │ │ │ ├── popperOffsets.js │ │ │ ├── popperOffsets.js.flow │ │ │ ├── preventOverflow.d.ts │ │ │ ├── preventOverflow.js │ │ │ └── preventOverflow.js.flow │ │ ├── popper-base.d.ts │ │ ├── popper-base.js │ │ ├── popper-base.js.flow │ │ ├── popper-lite.d.ts │ │ ├── popper-lite.js │ │ ├── popper-lite.js.flow │ │ ├── popper.d.ts │ │ ├── popper.js │ │ ├── popper.js.flow │ │ ├── types.d.ts │ │ ├── types.js │ │ ├── types.js.flow │ │ └── utils │ │ │ ├── computeAutoPlacement.d.ts │ │ │ ├── computeAutoPlacement.js │ │ │ ├── computeAutoPlacement.js.flow │ │ │ ├── computeOffsets.d.ts │ │ │ ├── computeOffsets.js │ │ │ ├── computeOffsets.js.flow │ │ │ ├── debounce.d.ts │ │ │ ├── debounce.js │ │ │ ├── debounce.js.flow │ │ │ ├── detectOverflow.d.ts │ │ │ ├── detectOverflow.js │ │ │ ├── detectOverflow.js.flow │ │ │ ├── expandToHashMap.d.ts │ │ │ ├── expandToHashMap.js │ │ │ ├── expandToHashMap.js.flow │ │ │ ├── getAltAxis.d.ts │ │ │ ├── getAltAxis.js │ │ │ ├── getAltAxis.js.flow │ │ │ ├── getAltLen.d.ts │ │ │ ├── getAltLen.js │ │ │ ├── getAltLen.js.flow │ │ │ ├── getBasePlacement.d.ts │ │ │ ├── getBasePlacement.js │ │ │ ├── getBasePlacement.js.flow │ │ │ ├── getFreshSideObject.d.ts │ │ │ ├── getFreshSideObject.js │ │ │ ├── getFreshSideObject.js.flow │ │ │ ├── getMainAxisFromPlacement.d.ts │ │ │ ├── getMainAxisFromPlacement.js │ │ │ ├── getMainAxisFromPlacement.js.flow │ │ │ ├── getOppositePlacement.d.ts │ │ │ ├── getOppositePlacement.js │ │ │ ├── getOppositePlacement.js.flow │ │ │ ├── getOppositeVariationPlacement.d.ts │ │ │ ├── getOppositeVariationPlacement.js │ │ │ ├── getOppositeVariationPlacement.js.flow │ │ │ ├── getVariation.d.ts │ │ │ ├── getVariation.js │ │ │ ├── getVariation.js.flow │ │ │ ├── math.d.ts │ │ │ ├── math.js │ │ │ ├── math.js.flow │ │ │ ├── mergeByName.d.ts │ │ │ ├── mergeByName.js │ │ │ ├── mergeByName.js.flow │ │ │ ├── mergePaddingObject.d.ts │ │ │ ├── mergePaddingObject.js │ │ │ ├── mergePaddingObject.js.flow │ │ │ ├── orderModifiers.d.ts │ │ │ ├── orderModifiers.js │ │ │ ├── orderModifiers.js.flow │ │ │ ├── rectToClientRect.d.ts │ │ │ ├── rectToClientRect.js │ │ │ ├── rectToClientRect.js.flow │ │ │ ├── uniqueBy.d.ts │ │ │ ├── uniqueBy.js │ │ │ ├── uniqueBy.js.flow │ │ │ ├── userAgent.d.ts │ │ │ ├── userAgent.js │ │ │ ├── userAgent.js.flow │ │ │ ├── within.d.ts │ │ │ ├── within.js │ │ │ └── within.js.flow │ │ └── package.json └── bootstrap │ ├── LICENSE │ ├── README.md │ ├── dist │ ├── css │ │ ├── bootstrap-grid.css │ │ ├── bootstrap-grid.css.map │ │ ├── bootstrap-grid.min.css │ │ ├── bootstrap-grid.min.css.map │ │ ├── bootstrap-grid.rtl.css │ │ ├── bootstrap-grid.rtl.css.map │ │ ├── bootstrap-grid.rtl.min.css │ │ ├── bootstrap-grid.rtl.min.css.map │ │ ├── bootstrap-reboot.css │ │ ├── bootstrap-reboot.css.map │ │ ├── bootstrap-reboot.min.css │ │ ├── bootstrap-reboot.min.css.map │ │ ├── bootstrap-reboot.rtl.css │ │ ├── bootstrap-reboot.rtl.css.map │ │ ├── bootstrap-reboot.rtl.min.css │ │ ├── bootstrap-reboot.rtl.min.css.map │ │ ├── bootstrap-utilities.css │ │ ├── bootstrap-utilities.css.map │ │ ├── bootstrap-utilities.min.css │ │ ├── bootstrap-utilities.min.css.map │ │ ├── bootstrap-utilities.rtl.css │ │ ├── bootstrap-utilities.rtl.css.map │ │ ├── bootstrap-utilities.rtl.min.css │ │ ├── bootstrap-utilities.rtl.min.css.map │ │ ├── bootstrap.css │ │ ├── bootstrap.css.map │ │ ├── bootstrap.min.css │ │ ├── bootstrap.min.css.map │ │ ├── bootstrap.rtl.css │ │ ├── bootstrap.rtl.css.map │ │ ├── bootstrap.rtl.min.css │ │ └── bootstrap.rtl.min.css.map │ └── js │ │ ├── bootstrap.bundle.js │ │ ├── bootstrap.bundle.js.map │ │ ├── bootstrap.bundle.min.js │ │ ├── bootstrap.bundle.min.js.map │ │ ├── bootstrap.esm.js │ │ ├── bootstrap.esm.js.map │ │ ├── bootstrap.esm.min.js │ │ ├── bootstrap.esm.min.js.map │ │ ├── bootstrap.js │ │ ├── bootstrap.js.map │ │ ├── bootstrap.min.js │ │ └── bootstrap.min.js.map │ ├── js │ ├── dist │ │ ├── alert.js │ │ ├── alert.js.map │ │ ├── base-component.js │ │ ├── base-component.js.map │ │ ├── button.js │ │ ├── button.js.map │ │ ├── carousel.js │ │ ├── carousel.js.map │ │ ├── collapse.js │ │ ├── collapse.js.map │ │ ├── dom │ │ │ ├── data.js │ │ │ ├── data.js.map │ │ │ ├── event-handler.js │ │ │ ├── event-handler.js.map │ │ │ ├── manipulator.js │ │ │ ├── manipulator.js.map │ │ │ ├── selector-engine.js │ │ │ └── selector-engine.js.map │ │ ├── dropdown.js │ │ ├── dropdown.js.map │ │ ├── modal.js │ │ ├── modal.js.map │ │ ├── offcanvas.js │ │ ├── offcanvas.js.map │ │ ├── popover.js │ │ ├── popover.js.map │ │ ├── scrollspy.js │ │ ├── scrollspy.js.map │ │ ├── tab.js │ │ ├── tab.js.map │ │ ├── toast.js │ │ ├── toast.js.map │ │ ├── tooltip.js │ │ ├── tooltip.js.map │ │ └── util │ │ │ ├── backdrop.js │ │ │ ├── backdrop.js.map │ │ │ ├── component-functions.js │ │ │ ├── component-functions.js.map │ │ │ ├── config.js │ │ │ ├── config.js.map │ │ │ ├── focustrap.js │ │ │ ├── focustrap.js.map │ │ │ ├── index.js │ │ │ ├── index.js.map │ │ │ ├── sanitizer.js │ │ │ ├── sanitizer.js.map │ │ │ ├── scrollbar.js │ │ │ ├── scrollbar.js.map │ │ │ ├── swipe.js │ │ │ ├── swipe.js.map │ │ │ ├── template-factory.js │ │ │ └── template-factory.js.map │ ├── index.esm.js │ ├── index.umd.js │ └── src │ │ ├── alert.js │ │ ├── base-component.js │ │ ├── button.js │ │ ├── carousel.js │ │ ├── collapse.js │ │ ├── dom │ │ ├── data.js │ │ ├── event-handler.js │ │ ├── manipulator.js │ │ └── selector-engine.js │ │ ├── dropdown.js │ │ ├── modal.js │ │ ├── offcanvas.js │ │ ├── popover.js │ │ ├── scrollspy.js │ │ ├── tab.js │ │ ├── toast.js │ │ ├── tooltip.js │ │ └── util │ │ ├── backdrop.js │ │ ├── component-functions.js │ │ ├── config.js │ │ ├── focustrap.js │ │ ├── index.js │ │ ├── sanitizer.js │ │ ├── scrollbar.js │ │ ├── swipe.js │ │ └── template-factory.js │ ├── package.json │ └── scss │ ├── _accordion.scss │ ├── _alert.scss │ ├── _badge.scss │ ├── _breadcrumb.scss │ ├── _button-group.scss │ ├── _buttons.scss │ ├── _card.scss │ ├── _carousel.scss │ ├── _close.scss │ ├── _containers.scss │ ├── _dropdown.scss │ ├── _forms.scss │ ├── _functions.scss │ ├── _grid.scss │ ├── _helpers.scss │ ├── _images.scss │ ├── _list-group.scss │ ├── _maps.scss │ ├── _mixins.scss │ ├── _modal.scss │ ├── _nav.scss │ ├── _navbar.scss │ ├── _offcanvas.scss │ ├── _pagination.scss │ ├── _placeholders.scss │ ├── _popover.scss │ ├── _progress.scss │ ├── _reboot.scss │ ├── _root.scss │ ├── _spinners.scss │ ├── _tables.scss │ ├── _toasts.scss │ ├── _tooltip.scss │ ├── _transitions.scss │ ├── _type.scss │ ├── _utilities.scss │ ├── _variables-dark.scss │ ├── _variables.scss │ ├── bootstrap-grid.scss │ ├── bootstrap-reboot.scss │ ├── bootstrap-utilities.scss │ ├── bootstrap.scss │ ├── forms │ ├── _floating-labels.scss │ ├── _form-check.scss │ ├── _form-control.scss │ ├── _form-range.scss │ ├── _form-select.scss │ ├── _form-text.scss │ ├── _input-group.scss │ ├── _labels.scss │ └── _validation.scss │ ├── helpers │ ├── _clearfix.scss │ ├── _color-bg.scss │ ├── _colored-links.scss │ ├── _focus-ring.scss │ ├── _icon-link.scss │ ├── _position.scss │ ├── _ratio.scss │ ├── _stacks.scss │ ├── _stretched-link.scss │ ├── _text-truncation.scss │ ├── _visually-hidden.scss │ └── _vr.scss │ ├── mixins │ ├── _alert.scss │ ├── _backdrop.scss │ ├── _banner.scss │ ├── _border-radius.scss │ ├── _box-shadow.scss │ ├── _breakpoints.scss │ ├── _buttons.scss │ ├── _caret.scss │ ├── _clearfix.scss │ ├── _color-mode.scss │ ├── _color-scheme.scss │ ├── _container.scss │ ├── _deprecate.scss │ ├── _forms.scss │ ├── _gradients.scss │ ├── _grid.scss │ ├── _image.scss │ ├── _list-group.scss │ ├── _lists.scss │ ├── _pagination.scss │ ├── _reset-text.scss │ ├── _resize.scss │ ├── _table-variants.scss │ ├── _text-truncate.scss │ ├── _transition.scss │ ├── _utilities.scss │ └── _visually-hidden.scss │ ├── utilities │ └── _api.scss │ └── vendor │ └── _rfs.scss ├── package-lock.json └── package.json /me.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ginhenrick/CV-bootstrap/16acb4b55478f33b0ff435284b68e6ce4a561d87/me.png -------------------------------------------------------------------------------- /node_modules/.package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "bootstrap-npm", 3 | "version": "1.0.0", 4 | "lockfileVersion": 3, 5 | "requires": true, 6 | "packages": { 7 | "node_modules/@popperjs/core": { 8 | "version": "2.11.8", 9 | "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz", 10 | "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==", 11 | "peer": true, 12 | "funding": { 13 | "type": "opencollective", 14 | "url": "https://opencollective.com/popperjs" 15 | } 16 | }, 17 | "node_modules/bootstrap": { 18 | "version": "5.3.2", 19 | "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.2.tgz", 20 | "integrity": "sha512-D32nmNWiQHo94BKHLmOrdjlL05q1c8oxbtBphQFb9Z5to6eGRDCm0QgeaZ4zFBHzfg2++rqa2JkqCcxDy0sH0g==", 21 | "funding": [ 22 | { 23 | "type": "github", 24 | "url": "https://github.com/sponsors/twbs" 25 | }, 26 | { 27 | "type": "opencollective", 28 | "url": "https://opencollective.com/bootstrap" 29 | } 30 | ], 31 | "peerDependencies": { 32 | "@popperjs/core": "^2.11.8" 33 | } 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2019 Federico Zivolo 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/cjs/enums.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/enums.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/cjs/popper-base.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper-base.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/cjs/popper-lite.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper-lite.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/cjs/popper.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/contains.js: -------------------------------------------------------------------------------- 1 | import { isShadowRoot } from "./instanceOf.js"; 2 | export default function contains(parent, child) { 3 | var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 4 | 5 | if (parent.contains(child)) { 6 | return true; 7 | } // then fallback to custom implementation with Shadow DOM support 8 | else if (rootNode && isShadowRoot(rootNode)) { 9 | var next = child; 10 | 11 | do { 12 | if (next && parent.isSameNode(next)) { 13 | return true; 14 | } // $FlowFixMe[prop-missing]: need a better way to handle this... 15 | 16 | 17 | next = next.parentNode || next.host; 18 | } while (next); 19 | } // Give up, the result is false 20 | 21 | 22 | return false; 23 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getBoundingClientRect.js: -------------------------------------------------------------------------------- 1 | import { isElement, isHTMLElement } from "./instanceOf.js"; 2 | import { round } from "../utils/math.js"; 3 | import getWindow from "./getWindow.js"; 4 | import isLayoutViewport from "./isLayoutViewport.js"; 5 | export default function getBoundingClientRect(element, includeScale, isFixedStrategy) { 6 | if (includeScale === void 0) { 7 | includeScale = false; 8 | } 9 | 10 | if (isFixedStrategy === void 0) { 11 | isFixedStrategy = false; 12 | } 13 | 14 | var clientRect = element.getBoundingClientRect(); 15 | var scaleX = 1; 16 | var scaleY = 1; 17 | 18 | if (includeScale && isHTMLElement(element)) { 19 | scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; 20 | scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; 21 | } 22 | 23 | var _ref = isElement(element) ? getWindow(element) : window, 24 | visualViewport = _ref.visualViewport; 25 | 26 | var addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 27 | var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX; 28 | var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY; 29 | var width = clientRect.width / scaleX; 30 | var height = clientRect.height / scaleY; 31 | return { 32 | width: width, 33 | height: height, 34 | top: y, 35 | right: x + width, 36 | bottom: y + height, 37 | left: x, 38 | x: x, 39 | y: y 40 | }; 41 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getComputedStyle.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | export default function getComputedStyle(element) { 3 | return getWindow(element).getComputedStyle(element); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getDocumentElement.js: -------------------------------------------------------------------------------- 1 | import { isElement } from "./instanceOf.js"; 2 | export default function getDocumentElement(element) { 3 | // $FlowFixMe[incompatible-return]: assume body is always available 4 | return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 5 | element.document) || window.document).documentElement; 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getDocumentRect.js: -------------------------------------------------------------------------------- 1 | import getDocumentElement from "./getDocumentElement.js"; 2 | import getComputedStyle from "./getComputedStyle.js"; 3 | import getWindowScrollBarX from "./getWindowScrollBarX.js"; 4 | import getWindowScroll from "./getWindowScroll.js"; 5 | import { max } from "../utils/math.js"; // Gets the entire size of the scrollable document area, even extending outside 6 | // of the `` and `` rect bounds if horizontally scrollable 7 | 8 | export default function getDocumentRect(element) { 9 | var _element$ownerDocumen; 10 | 11 | var html = getDocumentElement(element); 12 | var winScroll = getWindowScroll(element); 13 | var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 14 | var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 15 | var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 16 | var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 17 | var y = -winScroll.scrollTop; 18 | 19 | if (getComputedStyle(body || html).direction === 'rtl') { 20 | x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 21 | } 22 | 23 | return { 24 | width: width, 25 | height: height, 26 | x: x, 27 | y: y 28 | }; 29 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getHTMLElementScroll.js: -------------------------------------------------------------------------------- 1 | export default function getHTMLElementScroll(element) { 2 | return { 3 | scrollLeft: element.scrollLeft, 4 | scrollTop: element.scrollTop 5 | }; 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getLayoutRect.js: -------------------------------------------------------------------------------- 1 | import getBoundingClientRect from "./getBoundingClientRect.js"; // Returns the layout rect of an element relative to its offsetParent. Layout 2 | // means it doesn't take into account transforms. 3 | 4 | export default function getLayoutRect(element) { 5 | var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 6 | // Fixes https://github.com/popperjs/popper-core/issues/1223 7 | 8 | var width = element.offsetWidth; 9 | var height = element.offsetHeight; 10 | 11 | if (Math.abs(clientRect.width - width) <= 1) { 12 | width = clientRect.width; 13 | } 14 | 15 | if (Math.abs(clientRect.height - height) <= 1) { 16 | height = clientRect.height; 17 | } 18 | 19 | return { 20 | x: element.offsetLeft, 21 | y: element.offsetTop, 22 | width: width, 23 | height: height 24 | }; 25 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getNodeName.js: -------------------------------------------------------------------------------- 1 | export default function getNodeName(element) { 2 | return element ? (element.nodeName || '').toLowerCase() : null; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getNodeScroll.js: -------------------------------------------------------------------------------- 1 | import getWindowScroll from "./getWindowScroll.js"; 2 | import getWindow from "./getWindow.js"; 3 | import { isHTMLElement } from "./instanceOf.js"; 4 | import getHTMLElementScroll from "./getHTMLElementScroll.js"; 5 | export default function getNodeScroll(node) { 6 | if (node === getWindow(node) || !isHTMLElement(node)) { 7 | return getWindowScroll(node); 8 | } else { 9 | return getHTMLElementScroll(node); 10 | } 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getParentNode.js: -------------------------------------------------------------------------------- 1 | import getNodeName from "./getNodeName.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import { isShadowRoot } from "./instanceOf.js"; 4 | export default function getParentNode(element) { 5 | if (getNodeName(element) === 'html') { 6 | return element; 7 | } 8 | 9 | return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 10 | // $FlowFixMe[incompatible-return] 11 | // $FlowFixMe[prop-missing] 12 | element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 13 | element.parentNode || ( // DOM Element detected 14 | isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 15 | // $FlowFixMe[incompatible-call]: HTMLElement is a Node 16 | getDocumentElement(element) // fallback 17 | 18 | ); 19 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getScrollParent.js: -------------------------------------------------------------------------------- 1 | import getParentNode from "./getParentNode.js"; 2 | import isScrollParent from "./isScrollParent.js"; 3 | import getNodeName from "./getNodeName.js"; 4 | import { isHTMLElement } from "./instanceOf.js"; 5 | export default function getScrollParent(node) { 6 | if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 7 | // $FlowFixMe[incompatible-return]: assume body is always available 8 | return node.ownerDocument.body; 9 | } 10 | 11 | if (isHTMLElement(node) && isScrollParent(node)) { 12 | return node; 13 | } 14 | 15 | return getScrollParent(getParentNode(node)); 16 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getViewportRect.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import getWindowScrollBarX from "./getWindowScrollBarX.js"; 4 | import isLayoutViewport from "./isLayoutViewport.js"; 5 | export default function getViewportRect(element, strategy) { 6 | var win = getWindow(element); 7 | var html = getDocumentElement(element); 8 | var visualViewport = win.visualViewport; 9 | var width = html.clientWidth; 10 | var height = html.clientHeight; 11 | var x = 0; 12 | var y = 0; 13 | 14 | if (visualViewport) { 15 | width = visualViewport.width; 16 | height = visualViewport.height; 17 | var layoutViewport = isLayoutViewport(); 18 | 19 | if (layoutViewport || !layoutViewport && strategy === 'fixed') { 20 | x = visualViewport.offsetLeft; 21 | y = visualViewport.offsetTop; 22 | } 23 | } 24 | 25 | return { 26 | width: width, 27 | height: height, 28 | x: x + getWindowScrollBarX(element), 29 | y: y 30 | }; 31 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getWindow.js: -------------------------------------------------------------------------------- 1 | export default function getWindow(node) { 2 | if (node == null) { 3 | return window; 4 | } 5 | 6 | if (node.toString() !== '[object Window]') { 7 | var ownerDocument = node.ownerDocument; 8 | return ownerDocument ? ownerDocument.defaultView || window : window; 9 | } 10 | 11 | return node; 12 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getWindowScroll.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | export default function getWindowScroll(node) { 3 | var win = getWindow(node); 4 | var scrollLeft = win.pageXOffset; 5 | var scrollTop = win.pageYOffset; 6 | return { 7 | scrollLeft: scrollLeft, 8 | scrollTop: scrollTop 9 | }; 10 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/getWindowScrollBarX.js: -------------------------------------------------------------------------------- 1 | import getBoundingClientRect from "./getBoundingClientRect.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import getWindowScroll from "./getWindowScroll.js"; 4 | export default function getWindowScrollBarX(element) { 5 | // If has a CSS width greater than the viewport, then this will be 6 | // incorrect for RTL. 7 | // Popper 1 is broken in this case and never had a bug report so let's assume 8 | // it's not an issue. I don't think anyone ever specifies width on 9 | // anyway. 10 | // Browsers where the left scrollbar doesn't cause an issue report `0` for 11 | // this (e.g. Edge 2019, IE11, Safari) 12 | return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 13 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/instanceOf.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | 3 | function isElement(node) { 4 | var OwnElement = getWindow(node).Element; 5 | return node instanceof OwnElement || node instanceof Element; 6 | } 7 | 8 | function isHTMLElement(node) { 9 | var OwnElement = getWindow(node).HTMLElement; 10 | return node instanceof OwnElement || node instanceof HTMLElement; 11 | } 12 | 13 | function isShadowRoot(node) { 14 | // IE 11 has no ShadowRoot 15 | if (typeof ShadowRoot === 'undefined') { 16 | return false; 17 | } 18 | 19 | var OwnElement = getWindow(node).ShadowRoot; 20 | return node instanceof OwnElement || node instanceof ShadowRoot; 21 | } 22 | 23 | export { isElement, isHTMLElement, isShadowRoot }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/isLayoutViewport.js: -------------------------------------------------------------------------------- 1 | import getUAString from "../utils/userAgent.js"; 2 | export default function isLayoutViewport() { 3 | return !/^((?!chrome|android).)*safari/i.test(getUAString()); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/isScrollParent.js: -------------------------------------------------------------------------------- 1 | import getComputedStyle from "./getComputedStyle.js"; 2 | export default function isScrollParent(element) { 3 | // Firefox wants us to check `-x` and `-y` variations as well 4 | var _getComputedStyle = getComputedStyle(element), 5 | overflow = _getComputedStyle.overflow, 6 | overflowX = _getComputedStyle.overflowX, 7 | overflowY = _getComputedStyle.overflowY; 8 | 9 | return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 10 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/isTableElement.js: -------------------------------------------------------------------------------- 1 | import getNodeName from "./getNodeName.js"; 2 | export default function isTableElement(element) { 3 | return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/dom-utils/listScrollParents.js: -------------------------------------------------------------------------------- 1 | import getScrollParent from "./getScrollParent.js"; 2 | import getParentNode from "./getParentNode.js"; 3 | import getWindow from "./getWindow.js"; 4 | import isScrollParent from "./isScrollParent.js"; 5 | /* 6 | given a DOM element, return the list of all scroll parents, up the list of ancesors 7 | until we get to the top window object. This list is what we attach scroll listeners 8 | to, because if any of these parent elements scroll, we'll need to re-calculate the 9 | reference element's position. 10 | */ 11 | 12 | export default function listScrollParents(element, list) { 13 | var _element$ownerDocumen; 14 | 15 | if (list === void 0) { 16 | list = []; 17 | } 18 | 19 | var scrollParent = getScrollParent(element); 20 | var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 21 | var win = getWindow(scrollParent); 22 | var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 23 | var updatedList = list.concat(target); 24 | return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 25 | updatedList.concat(listScrollParents(getParentNode(target))); 26 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/enums.js: -------------------------------------------------------------------------------- 1 | export var top = 'top'; 2 | export var bottom = 'bottom'; 3 | export var right = 'right'; 4 | export var left = 'left'; 5 | export var auto = 'auto'; 6 | export var basePlacements = [top, bottom, right, left]; 7 | export var start = 'start'; 8 | export var end = 'end'; 9 | export var clippingParents = 'clippingParents'; 10 | export var viewport = 'viewport'; 11 | export var popper = 'popper'; 12 | export var reference = 'reference'; 13 | export var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 14 | return acc.concat([placement + "-" + start, placement + "-" + end]); 15 | }, []); 16 | export var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 17 | return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 18 | }, []); // modifiers that need to read the DOM 19 | 20 | export var beforeRead = 'beforeRead'; 21 | export var read = 'read'; 22 | export var afterRead = 'afterRead'; // pure-logic modifiers 23 | 24 | export var beforeMain = 'beforeMain'; 25 | export var main = 'main'; 26 | export var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 27 | 28 | export var beforeWrite = 'beforeWrite'; 29 | export var write = 'write'; 30 | export var afterWrite = 'afterWrite'; 31 | export var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/index.js: -------------------------------------------------------------------------------- 1 | export * from "./enums.js"; 2 | export * from "./modifiers/index.js"; // eslint-disable-next-line import/no-unused-modules 3 | 4 | export { popperGenerator, detectOverflow, createPopper as createPopperBase } from "./createPopper.js"; // eslint-disable-next-line import/no-unused-modules 5 | 6 | export { createPopper } from "./popper.js"; // eslint-disable-next-line import/no-unused-modules 7 | 8 | export { createPopper as createPopperLite } from "./popper-lite.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/modifiers/eventListeners.js: -------------------------------------------------------------------------------- 1 | import getWindow from "../dom-utils/getWindow.js"; // eslint-disable-next-line import/no-unused-modules 2 | 3 | var passive = { 4 | passive: true 5 | }; 6 | 7 | function effect(_ref) { 8 | var state = _ref.state, 9 | instance = _ref.instance, 10 | options = _ref.options; 11 | var _options$scroll = options.scroll, 12 | scroll = _options$scroll === void 0 ? true : _options$scroll, 13 | _options$resize = options.resize, 14 | resize = _options$resize === void 0 ? true : _options$resize; 15 | var window = getWindow(state.elements.popper); 16 | var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 17 | 18 | if (scroll) { 19 | scrollParents.forEach(function (scrollParent) { 20 | scrollParent.addEventListener('scroll', instance.update, passive); 21 | }); 22 | } 23 | 24 | if (resize) { 25 | window.addEventListener('resize', instance.update, passive); 26 | } 27 | 28 | return function () { 29 | if (scroll) { 30 | scrollParents.forEach(function (scrollParent) { 31 | scrollParent.removeEventListener('scroll', instance.update, passive); 32 | }); 33 | } 34 | 35 | if (resize) { 36 | window.removeEventListener('resize', instance.update, passive); 37 | } 38 | }; 39 | } // eslint-disable-next-line import/no-unused-modules 40 | 41 | 42 | export default { 43 | name: 'eventListeners', 44 | enabled: true, 45 | phase: 'write', 46 | fn: function fn() {}, 47 | effect: effect, 48 | data: {} 49 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/modifiers/hide.js: -------------------------------------------------------------------------------- 1 | import { top, bottom, left, right } from "../enums.js"; 2 | import detectOverflow from "../utils/detectOverflow.js"; 3 | 4 | function getSideOffsets(overflow, rect, preventedOffsets) { 5 | if (preventedOffsets === void 0) { 6 | preventedOffsets = { 7 | x: 0, 8 | y: 0 9 | }; 10 | } 11 | 12 | return { 13 | top: overflow.top - rect.height - preventedOffsets.y, 14 | right: overflow.right - rect.width + preventedOffsets.x, 15 | bottom: overflow.bottom - rect.height + preventedOffsets.y, 16 | left: overflow.left - rect.width - preventedOffsets.x 17 | }; 18 | } 19 | 20 | function isAnySideFullyClipped(overflow) { 21 | return [top, right, bottom, left].some(function (side) { 22 | return overflow[side] >= 0; 23 | }); 24 | } 25 | 26 | function hide(_ref) { 27 | var state = _ref.state, 28 | name = _ref.name; 29 | var referenceRect = state.rects.reference; 30 | var popperRect = state.rects.popper; 31 | var preventedOffsets = state.modifiersData.preventOverflow; 32 | var referenceOverflow = detectOverflow(state, { 33 | elementContext: 'reference' 34 | }); 35 | var popperAltOverflow = detectOverflow(state, { 36 | altBoundary: true 37 | }); 38 | var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 39 | var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 40 | var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 41 | var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 42 | state.modifiersData[name] = { 43 | referenceClippingOffsets: referenceClippingOffsets, 44 | popperEscapeOffsets: popperEscapeOffsets, 45 | isReferenceHidden: isReferenceHidden, 46 | hasPopperEscaped: hasPopperEscaped 47 | }; 48 | state.attributes.popper = Object.assign({}, state.attributes.popper, { 49 | 'data-popper-reference-hidden': isReferenceHidden, 50 | 'data-popper-escaped': hasPopperEscaped 51 | }); 52 | } // eslint-disable-next-line import/no-unused-modules 53 | 54 | 55 | export default { 56 | name: 'hide', 57 | enabled: true, 58 | phase: 'main', 59 | requiresIfExists: ['preventOverflow'], 60 | fn: hide 61 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/modifiers/index.js: -------------------------------------------------------------------------------- 1 | export { default as applyStyles } from "./applyStyles.js"; 2 | export { default as arrow } from "./arrow.js"; 3 | export { default as computeStyles } from "./computeStyles.js"; 4 | export { default as eventListeners } from "./eventListeners.js"; 5 | export { default as flip } from "./flip.js"; 6 | export { default as hide } from "./hide.js"; 7 | export { default as offset } from "./offset.js"; 8 | export { default as popperOffsets } from "./popperOffsets.js"; 9 | export { default as preventOverflow } from "./preventOverflow.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/modifiers/offset.js: -------------------------------------------------------------------------------- 1 | import getBasePlacement from "../utils/getBasePlacement.js"; 2 | import { top, left, right, placements } from "../enums.js"; // eslint-disable-next-line import/no-unused-modules 3 | 4 | export function distanceAndSkiddingToXY(placement, rects, offset) { 5 | var basePlacement = getBasePlacement(placement); 6 | var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 7 | 8 | var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 9 | placement: placement 10 | })) : offset, 11 | skidding = _ref[0], 12 | distance = _ref[1]; 13 | 14 | skidding = skidding || 0; 15 | distance = (distance || 0) * invertDistance; 16 | return [left, right].indexOf(basePlacement) >= 0 ? { 17 | x: distance, 18 | y: skidding 19 | } : { 20 | x: skidding, 21 | y: distance 22 | }; 23 | } 24 | 25 | function offset(_ref2) { 26 | var state = _ref2.state, 27 | options = _ref2.options, 28 | name = _ref2.name; 29 | var _options$offset = options.offset, 30 | offset = _options$offset === void 0 ? [0, 0] : _options$offset; 31 | var data = placements.reduce(function (acc, placement) { 32 | acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 33 | return acc; 34 | }, {}); 35 | var _data$state$placement = data[state.placement], 36 | x = _data$state$placement.x, 37 | y = _data$state$placement.y; 38 | 39 | if (state.modifiersData.popperOffsets != null) { 40 | state.modifiersData.popperOffsets.x += x; 41 | state.modifiersData.popperOffsets.y += y; 42 | } 43 | 44 | state.modifiersData[name] = data; 45 | } // eslint-disable-next-line import/no-unused-modules 46 | 47 | 48 | export default { 49 | name: 'offset', 50 | enabled: true, 51 | phase: 'main', 52 | requires: ['popperOffsets'], 53 | fn: offset 54 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/modifiers/popperOffsets.js: -------------------------------------------------------------------------------- 1 | import computeOffsets from "../utils/computeOffsets.js"; 2 | 3 | function popperOffsets(_ref) { 4 | var state = _ref.state, 5 | name = _ref.name; 6 | // Offsets are the actual position the popper needs to have to be 7 | // properly positioned near its reference element 8 | // This is the most basic placement, and will be adjusted by 9 | // the modifiers in the next step 10 | state.modifiersData[name] = computeOffsets({ 11 | reference: state.rects.reference, 12 | element: state.rects.popper, 13 | strategy: 'absolute', 14 | placement: state.placement 15 | }); 16 | } // eslint-disable-next-line import/no-unused-modules 17 | 18 | 19 | export default { 20 | name: 'popperOffsets', 21 | enabled: true, 22 | phase: 'read', 23 | fn: popperOffsets, 24 | data: {} 25 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/popper-base.js: -------------------------------------------------------------------------------- 1 | import { createPopper, popperGenerator, detectOverflow } from "./createPopper.js"; 2 | // eslint-disable-next-line import/no-unused-modules 3 | export { createPopper, popperGenerator, detectOverflow }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/popper-lite.js: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper.js"; 2 | import eventListeners from "./modifiers/eventListeners.js"; 3 | import popperOffsets from "./modifiers/popperOffsets.js"; 4 | import computeStyles from "./modifiers/computeStyles.js"; 5 | import applyStyles from "./modifiers/applyStyles.js"; 6 | var defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles]; 7 | var createPopper = /*#__PURE__*/popperGenerator({ 8 | defaultModifiers: defaultModifiers 9 | }); // eslint-disable-next-line import/no-unused-modules 10 | 11 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/popper.js: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper.js"; 2 | import eventListeners from "./modifiers/eventListeners.js"; 3 | import popperOffsets from "./modifiers/popperOffsets.js"; 4 | import computeStyles from "./modifiers/computeStyles.js"; 5 | import applyStyles from "./modifiers/applyStyles.js"; 6 | import offset from "./modifiers/offset.js"; 7 | import flip from "./modifiers/flip.js"; 8 | import preventOverflow from "./modifiers/preventOverflow.js"; 9 | import arrow from "./modifiers/arrow.js"; 10 | import hide from "./modifiers/hide.js"; 11 | var defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles, offset, flip, preventOverflow, arrow, hide]; 12 | var createPopper = /*#__PURE__*/popperGenerator({ 13 | defaultModifiers: defaultModifiers 14 | }); // eslint-disable-next-line import/no-unused-modules 15 | 16 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; // eslint-disable-next-line import/no-unused-modules 17 | 18 | export { createPopper as createPopperLite } from "./popper-lite.js"; // eslint-disable-next-line import/no-unused-modules 19 | 20 | export * from "./modifiers/index.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/types.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ginhenrick/CV-bootstrap/16acb4b55478f33b0ff435284b68e6ce4a561d87/node_modules/@popperjs/core/dist/esm/types.js -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/computeAutoPlacement.js: -------------------------------------------------------------------------------- 1 | import getVariation from "./getVariation.js"; 2 | import { variationPlacements, basePlacements, placements as allPlacements } from "../enums.js"; 3 | import detectOverflow from "./detectOverflow.js"; 4 | import getBasePlacement from "./getBasePlacement.js"; 5 | export default function computeAutoPlacement(state, options) { 6 | if (options === void 0) { 7 | options = {}; 8 | } 9 | 10 | var _options = options, 11 | placement = _options.placement, 12 | boundary = _options.boundary, 13 | rootBoundary = _options.rootBoundary, 14 | padding = _options.padding, 15 | flipVariations = _options.flipVariations, 16 | _options$allowedAutoP = _options.allowedAutoPlacements, 17 | allowedAutoPlacements = _options$allowedAutoP === void 0 ? allPlacements : _options$allowedAutoP; 18 | var variation = getVariation(placement); 19 | var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 20 | return getVariation(placement) === variation; 21 | }) : basePlacements; 22 | var allowedPlacements = placements.filter(function (placement) { 23 | return allowedAutoPlacements.indexOf(placement) >= 0; 24 | }); 25 | 26 | if (allowedPlacements.length === 0) { 27 | allowedPlacements = placements; 28 | } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 29 | 30 | 31 | var overflows = allowedPlacements.reduce(function (acc, placement) { 32 | acc[placement] = detectOverflow(state, { 33 | placement: placement, 34 | boundary: boundary, 35 | rootBoundary: rootBoundary, 36 | padding: padding 37 | })[getBasePlacement(placement)]; 38 | return acc; 39 | }, {}); 40 | return Object.keys(overflows).sort(function (a, b) { 41 | return overflows[a] - overflows[b]; 42 | }); 43 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/computeOffsets.js: -------------------------------------------------------------------------------- 1 | import getBasePlacement from "./getBasePlacement.js"; 2 | import getVariation from "./getVariation.js"; 3 | import getMainAxisFromPlacement from "./getMainAxisFromPlacement.js"; 4 | import { top, right, bottom, left, start, end } from "../enums.js"; 5 | export default function computeOffsets(_ref) { 6 | var reference = _ref.reference, 7 | element = _ref.element, 8 | placement = _ref.placement; 9 | var basePlacement = placement ? getBasePlacement(placement) : null; 10 | var variation = placement ? getVariation(placement) : null; 11 | var commonX = reference.x + reference.width / 2 - element.width / 2; 12 | var commonY = reference.y + reference.height / 2 - element.height / 2; 13 | var offsets; 14 | 15 | switch (basePlacement) { 16 | case top: 17 | offsets = { 18 | x: commonX, 19 | y: reference.y - element.height 20 | }; 21 | break; 22 | 23 | case bottom: 24 | offsets = { 25 | x: commonX, 26 | y: reference.y + reference.height 27 | }; 28 | break; 29 | 30 | case right: 31 | offsets = { 32 | x: reference.x + reference.width, 33 | y: commonY 34 | }; 35 | break; 36 | 37 | case left: 38 | offsets = { 39 | x: reference.x - element.width, 40 | y: commonY 41 | }; 42 | break; 43 | 44 | default: 45 | offsets = { 46 | x: reference.x, 47 | y: reference.y 48 | }; 49 | } 50 | 51 | var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 52 | 53 | if (mainAxis != null) { 54 | var len = mainAxis === 'y' ? 'height' : 'width'; 55 | 56 | switch (variation) { 57 | case start: 58 | offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 59 | break; 60 | 61 | case end: 62 | offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 63 | break; 64 | 65 | default: 66 | } 67 | } 68 | 69 | return offsets; 70 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/debounce.js: -------------------------------------------------------------------------------- 1 | export default function debounce(fn) { 2 | var pending; 3 | return function () { 4 | if (!pending) { 5 | pending = new Promise(function (resolve) { 6 | Promise.resolve().then(function () { 7 | pending = undefined; 8 | resolve(fn()); 9 | }); 10 | }); 11 | } 12 | 13 | return pending; 14 | }; 15 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/expandToHashMap.js: -------------------------------------------------------------------------------- 1 | export default function expandToHashMap(value, keys) { 2 | return keys.reduce(function (hashMap, key) { 3 | hashMap[key] = value; 4 | return hashMap; 5 | }, {}); 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getAltAxis.js: -------------------------------------------------------------------------------- 1 | export default function getAltAxis(axis) { 2 | return axis === 'x' ? 'y' : 'x'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getAltLen.js: -------------------------------------------------------------------------------- 1 | export default function getAltLen(len) { 2 | return len === 'width' ? 'height' : 'width'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getBasePlacement.js: -------------------------------------------------------------------------------- 1 | import { auto } from "../enums.js"; 2 | export default function getBasePlacement(placement) { 3 | return placement.split('-')[0]; 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getFreshSideObject.js: -------------------------------------------------------------------------------- 1 | export default function getFreshSideObject() { 2 | return { 3 | top: 0, 4 | right: 0, 5 | bottom: 0, 6 | left: 0 7 | }; 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getMainAxisFromPlacement.js: -------------------------------------------------------------------------------- 1 | export default function getMainAxisFromPlacement(placement) { 2 | return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getOppositePlacement.js: -------------------------------------------------------------------------------- 1 | var hash = { 2 | left: 'right', 3 | right: 'left', 4 | bottom: 'top', 5 | top: 'bottom' 6 | }; 7 | export default function getOppositePlacement(placement) { 8 | return placement.replace(/left|right|bottom|top/g, function (matched) { 9 | return hash[matched]; 10 | }); 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getOppositeVariationPlacement.js: -------------------------------------------------------------------------------- 1 | var hash = { 2 | start: 'end', 3 | end: 'start' 4 | }; 5 | export default function getOppositeVariationPlacement(placement) { 6 | return placement.replace(/start|end/g, function (matched) { 7 | return hash[matched]; 8 | }); 9 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/getVariation.js: -------------------------------------------------------------------------------- 1 | export default function getVariation(placement) { 2 | return placement.split('-')[1]; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/math.js: -------------------------------------------------------------------------------- 1 | export var max = Math.max; 2 | export var min = Math.min; 3 | export var round = Math.round; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/mergeByName.js: -------------------------------------------------------------------------------- 1 | export default function mergeByName(modifiers) { 2 | var merged = modifiers.reduce(function (merged, current) { 3 | var existing = merged[current.name]; 4 | merged[current.name] = existing ? Object.assign({}, existing, current, { 5 | options: Object.assign({}, existing.options, current.options), 6 | data: Object.assign({}, existing.data, current.data) 7 | }) : current; 8 | return merged; 9 | }, {}); // IE11 does not support Object.values 10 | 11 | return Object.keys(merged).map(function (key) { 12 | return merged[key]; 13 | }); 14 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/mergePaddingObject.js: -------------------------------------------------------------------------------- 1 | import getFreshSideObject from "./getFreshSideObject.js"; 2 | export default function mergePaddingObject(paddingObject) { 3 | return Object.assign({}, getFreshSideObject(), paddingObject); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/orderModifiers.js: -------------------------------------------------------------------------------- 1 | import { modifierPhases } from "../enums.js"; // source: https://stackoverflow.com/questions/49875255 2 | 3 | function order(modifiers) { 4 | var map = new Map(); 5 | var visited = new Set(); 6 | var result = []; 7 | modifiers.forEach(function (modifier) { 8 | map.set(modifier.name, modifier); 9 | }); // On visiting object, check for its dependencies and visit them recursively 10 | 11 | function sort(modifier) { 12 | visited.add(modifier.name); 13 | var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 14 | requires.forEach(function (dep) { 15 | if (!visited.has(dep)) { 16 | var depModifier = map.get(dep); 17 | 18 | if (depModifier) { 19 | sort(depModifier); 20 | } 21 | } 22 | }); 23 | result.push(modifier); 24 | } 25 | 26 | modifiers.forEach(function (modifier) { 27 | if (!visited.has(modifier.name)) { 28 | // check for visited object 29 | sort(modifier); 30 | } 31 | }); 32 | return result; 33 | } 34 | 35 | export default function orderModifiers(modifiers) { 36 | // order based on dependencies 37 | var orderedModifiers = order(modifiers); // order based on phase 38 | 39 | return modifierPhases.reduce(function (acc, phase) { 40 | return acc.concat(orderedModifiers.filter(function (modifier) { 41 | return modifier.phase === phase; 42 | })); 43 | }, []); 44 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/rectToClientRect.js: -------------------------------------------------------------------------------- 1 | export default function rectToClientRect(rect) { 2 | return Object.assign({}, rect, { 3 | left: rect.x, 4 | top: rect.y, 5 | right: rect.x + rect.width, 6 | bottom: rect.y + rect.height 7 | }); 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/uniqueBy.js: -------------------------------------------------------------------------------- 1 | export default function uniqueBy(arr, fn) { 2 | var identifiers = new Set(); 3 | return arr.filter(function (item) { 4 | var identifier = fn(item); 5 | 6 | if (!identifiers.has(identifier)) { 7 | identifiers.add(identifier); 8 | return true; 9 | } 10 | }); 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/userAgent.js: -------------------------------------------------------------------------------- 1 | export default function getUAString() { 2 | var uaData = navigator.userAgentData; 3 | 4 | if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) { 5 | return uaData.brands.map(function (item) { 6 | return item.brand + "/" + item.version; 7 | }).join(' '); 8 | } 9 | 10 | return navigator.userAgent; 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/esm/utils/within.js: -------------------------------------------------------------------------------- 1 | import { max as mathMax, min as mathMin } from "./math.js"; 2 | export function within(min, value, max) { 3 | return mathMax(min, mathMin(value, max)); 4 | } 5 | export function withinMaxClamp(min, value, max) { 6 | var v = within(min, value, max); 7 | return v > max ? max : v; 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/umd/enums.min.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @popperjs/core v2.11.8 - MIT License 3 | */ 4 | 5 | !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).Popper={})}(this,(function(e){"use strict";var t="bottom",r="right",o="left",n="auto",a=["top",t,r,o],i="start",f="end",p=a.reduce((function(e,t){return e.concat([t+"-"+i,t+"-"+f])}),[]),c=[].concat(a,[n]).reduce((function(e,t){return e.concat([t,t+"-"+i,t+"-"+f])}),[]),d="beforeRead",s="read",u="afterRead",l="beforeMain",b="main",m="afterMain",P="beforeWrite",g="write",h="afterWrite",v=[d,s,u,l,b,m,P,g,h];e.afterMain=m,e.afterRead=u,e.afterWrite=h,e.auto=n,e.basePlacements=a,e.beforeMain=l,e.beforeRead=d,e.beforeWrite=P,e.bottom=t,e.clippingParents="clippingParents",e.end=f,e.left=o,e.main=b,e.modifierPhases=v,e.placements=c,e.popper="popper",e.read=s,e.reference="reference",e.right=r,e.start=i,e.top="top",e.variationPlacements=p,e.viewport="viewport",e.write=g,Object.defineProperty(e,"__esModule",{value:!0})})); 6 | //# sourceMappingURL=enums.min.js.map 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/umd/enums.min.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/enums.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/umd/popper-base.min.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper-base.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/umd/popper-lite.min.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper-lite.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/dist/umd/popper.min.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export * from '../../lib/popper.js' 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/index.d.ts: -------------------------------------------------------------------------------- 1 | export * from './lib'; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/createPopper.d.ts: -------------------------------------------------------------------------------- 1 | import type { OptionsGeneric, Modifier, Instance, VirtualElement } from "./types"; 2 | import detectOverflow from "./utils/detectOverflow"; 3 | declare type PopperGeneratorArgs = { 4 | defaultModifiers?: Array>; 5 | defaultOptions?: Partial>; 6 | }; 7 | export declare function popperGenerator(generatorOptions?: PopperGeneratorArgs): >>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial>) => Instance; 8 | export declare const createPopper: >>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial>) => Instance; 9 | export { detectOverflow }; 10 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/contains.d.ts: -------------------------------------------------------------------------------- 1 | export default function contains(parent: Element, child: Element): boolean; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/contains.js: -------------------------------------------------------------------------------- 1 | import { isShadowRoot } from "./instanceOf.js"; 2 | export default function contains(parent, child) { 3 | var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 4 | 5 | if (parent.contains(child)) { 6 | return true; 7 | } // then fallback to custom implementation with Shadow DOM support 8 | else if (rootNode && isShadowRoot(rootNode)) { 9 | var next = child; 10 | 11 | do { 12 | if (next && parent.isSameNode(next)) { 13 | return true; 14 | } // $FlowFixMe[prop-missing]: need a better way to handle this... 15 | 16 | 17 | next = next.parentNode || next.host; 18 | } while (next); 19 | } // Give up, the result is false 20 | 21 | 22 | return false; 23 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/contains.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { isShadowRoot } from './instanceOf'; 3 | 4 | export default function contains(parent: Element, child: Element) { 5 | const rootNode = child.getRootNode && child.getRootNode(); 6 | 7 | // First, attempt with faster native method 8 | if (parent.contains(child)) { 9 | return true; 10 | } 11 | // then fallback to custom implementation with Shadow DOM support 12 | else if (rootNode && isShadowRoot(rootNode)) { 13 | let next = child; 14 | do { 15 | if (next && parent.isSameNode(next)) { 16 | return true; 17 | } 18 | // $FlowFixMe[prop-missing]: need a better way to handle this... 19 | next = next.parentNode || next.host; 20 | } while (next); 21 | } 22 | 23 | // Give up, the result is false 24 | return false; 25 | } 26 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { ClientRectObject, VirtualElement } from "../types"; 2 | export default function getBoundingClientRect(element: Element | VirtualElement, includeScale?: boolean, isFixedStrategy?: boolean): ClientRectObject; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js: -------------------------------------------------------------------------------- 1 | import { isElement, isHTMLElement } from "./instanceOf.js"; 2 | import { round } from "../utils/math.js"; 3 | import getWindow from "./getWindow.js"; 4 | import isLayoutViewport from "./isLayoutViewport.js"; 5 | export default function getBoundingClientRect(element, includeScale, isFixedStrategy) { 6 | if (includeScale === void 0) { 7 | includeScale = false; 8 | } 9 | 10 | if (isFixedStrategy === void 0) { 11 | isFixedStrategy = false; 12 | } 13 | 14 | var clientRect = element.getBoundingClientRect(); 15 | var scaleX = 1; 16 | var scaleY = 1; 17 | 18 | if (includeScale && isHTMLElement(element)) { 19 | scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; 20 | scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; 21 | } 22 | 23 | var _ref = isElement(element) ? getWindow(element) : window, 24 | visualViewport = _ref.visualViewport; 25 | 26 | var addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 27 | var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX; 28 | var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY; 29 | var width = clientRect.width / scaleX; 30 | var height = clientRect.height / scaleY; 31 | return { 32 | width: width, 33 | height: height, 34 | top: y, 35 | right: x + width, 36 | bottom: y + height, 37 | left: x, 38 | x: x, 39 | y: y 40 | }; 41 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { ClientRectObject, VirtualElement } from '../types'; 3 | import { isElement, isHTMLElement } from './instanceOf'; 4 | import { round } from '../utils/math'; 5 | import getWindow from './getWindow'; 6 | import isLayoutViewport from './isLayoutViewport'; 7 | 8 | export default function getBoundingClientRect( 9 | element: Element | VirtualElement, 10 | includeScale: boolean = false, 11 | isFixedStrategy: boolean = false 12 | ): ClientRectObject { 13 | const clientRect = element.getBoundingClientRect(); 14 | let scaleX = 1; 15 | let scaleY = 1; 16 | 17 | if (includeScale && isHTMLElement(element)) { 18 | scaleX = 19 | (element: HTMLElement).offsetWidth > 0 20 | ? round(clientRect.width) / (element: HTMLElement).offsetWidth || 1 21 | : 1; 22 | scaleY = 23 | (element: HTMLElement).offsetHeight > 0 24 | ? round(clientRect.height) / (element: HTMLElement).offsetHeight || 1 25 | : 1; 26 | } 27 | 28 | const { visualViewport } = isElement(element) ? getWindow(element) : window; 29 | const addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 30 | 31 | const x = 32 | (clientRect.left + 33 | (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / 34 | scaleX; 35 | const y = 36 | (clientRect.top + 37 | (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / 38 | scaleY; 39 | const width = clientRect.width / scaleX; 40 | const height = clientRect.height / scaleY; 41 | 42 | return { 43 | width, 44 | height, 45 | top: y, 46 | right: x + width, 47 | bottom: y + height, 48 | left: x, 49 | x, 50 | y, 51 | }; 52 | } 53 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getClippingRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { ClientRectObject, PositioningStrategy } from "../types"; 2 | import type { Boundary, RootBoundary } from "../enums"; 3 | export default function getClippingRect(element: Element, boundary: Boundary, rootBoundary: RootBoundary, strategy: PositioningStrategy): ClientRectObject; 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { Rect, VirtualElement, Window } from "../types"; 2 | export default function getCompositeRect(elementOrVirtualElement: Element | VirtualElement, offsetParent: Element | Window, isFixed?: boolean): Rect; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.d.ts: -------------------------------------------------------------------------------- 1 | export default function getComputedStyle(element: Element): CSSStyleDeclaration; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | export default function getComputedStyle(element) { 3 | return getWindow(element).getComputedStyle(element); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getWindow from './getWindow'; 3 | 4 | export default function getComputedStyle( 5 | element: Element 6 | ): CSSStyleDeclaration { 7 | return getWindow(element).getComputedStyle(element); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.d.ts: -------------------------------------------------------------------------------- 1 | import type { Window } from "../types"; 2 | export default function getDocumentElement(element: Element | Window): HTMLElement; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js: -------------------------------------------------------------------------------- 1 | import { isElement } from "./instanceOf.js"; 2 | export default function getDocumentElement(element) { 3 | // $FlowFixMe[incompatible-return]: assume body is always available 4 | return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 5 | element.document) || window.document).documentElement; 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { isElement } from './instanceOf'; 3 | import type { Window } from '../types'; 4 | 5 | export default function getDocumentElement( 6 | element: Element | Window 7 | ): HTMLElement { 8 | // $FlowFixMe[incompatible-return]: assume body is always available 9 | return ( 10 | (isElement(element) 11 | ? element.ownerDocument 12 | : // $FlowFixMe[prop-missing] 13 | element.document) || window.document 14 | ).documentElement; 15 | } 16 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { Rect } from "../types"; 2 | export default function getDocumentRect(element: HTMLElement): Rect; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js: -------------------------------------------------------------------------------- 1 | import getDocumentElement from "./getDocumentElement.js"; 2 | import getComputedStyle from "./getComputedStyle.js"; 3 | import getWindowScrollBarX from "./getWindowScrollBarX.js"; 4 | import getWindowScroll from "./getWindowScroll.js"; 5 | import { max } from "../utils/math.js"; // Gets the entire size of the scrollable document area, even extending outside 6 | // of the `` and `` rect bounds if horizontally scrollable 7 | 8 | export default function getDocumentRect(element) { 9 | var _element$ownerDocumen; 10 | 11 | var html = getDocumentElement(element); 12 | var winScroll = getWindowScroll(element); 13 | var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 14 | var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 15 | var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 16 | var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 17 | var y = -winScroll.scrollTop; 18 | 19 | if (getComputedStyle(body || html).direction === 'rtl') { 20 | x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 21 | } 22 | 23 | return { 24 | width: width, 25 | height: height, 26 | x: x, 27 | y: y 28 | }; 29 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Rect } from '../types'; 3 | import getDocumentElement from './getDocumentElement'; 4 | import getComputedStyle from './getComputedStyle'; 5 | import getWindowScrollBarX from './getWindowScrollBarX'; 6 | import getWindowScroll from './getWindowScroll'; 7 | import { max } from '../utils/math'; 8 | 9 | // Gets the entire size of the scrollable document area, even extending outside 10 | // of the `` and `` rect bounds if horizontally scrollable 11 | export default function getDocumentRect(element: HTMLElement): Rect { 12 | const html = getDocumentElement(element); 13 | const winScroll = getWindowScroll(element); 14 | const body = element.ownerDocument?.body; 15 | 16 | const width = max( 17 | html.scrollWidth, 18 | html.clientWidth, 19 | body ? body.scrollWidth : 0, 20 | body ? body.clientWidth : 0 21 | ); 22 | const height = max( 23 | html.scrollHeight, 24 | html.clientHeight, 25 | body ? body.scrollHeight : 0, 26 | body ? body.clientHeight : 0 27 | ); 28 | 29 | let x = -winScroll.scrollLeft + getWindowScrollBarX(element); 30 | const y = -winScroll.scrollTop; 31 | 32 | if (getComputedStyle(body || html).direction === 'rtl') { 33 | x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 34 | } 35 | 36 | return { width, height, x, y }; 37 | } 38 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.d.ts: -------------------------------------------------------------------------------- 1 | export default function getHTMLElementScroll(element: HTMLElement): { 2 | scrollLeft: number; 3 | scrollTop: number; 4 | }; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js: -------------------------------------------------------------------------------- 1 | export default function getHTMLElementScroll(element) { 2 | return { 3 | scrollLeft: element.scrollLeft, 4 | scrollTop: element.scrollTop 5 | }; 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function getHTMLElementScroll(element: HTMLElement) { 4 | return { 5 | scrollLeft: element.scrollLeft, 6 | scrollTop: element.scrollTop, 7 | }; 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { Rect } from "../types"; 2 | export default function getLayoutRect(element: HTMLElement): Rect; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js: -------------------------------------------------------------------------------- 1 | import getBoundingClientRect from "./getBoundingClientRect.js"; // Returns the layout rect of an element relative to its offsetParent. Layout 2 | // means it doesn't take into account transforms. 3 | 4 | export default function getLayoutRect(element) { 5 | var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 6 | // Fixes https://github.com/popperjs/popper-core/issues/1223 7 | 8 | var width = element.offsetWidth; 9 | var height = element.offsetHeight; 10 | 11 | if (Math.abs(clientRect.width - width) <= 1) { 12 | width = clientRect.width; 13 | } 14 | 15 | if (Math.abs(clientRect.height - height) <= 1) { 16 | height = clientRect.height; 17 | } 18 | 19 | return { 20 | x: element.offsetLeft, 21 | y: element.offsetTop, 22 | width: width, 23 | height: height 24 | }; 25 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Rect } from '../types'; 3 | import getBoundingClientRect from './getBoundingClientRect'; 4 | 5 | // Returns the layout rect of an element relative to its offsetParent. Layout 6 | // means it doesn't take into account transforms. 7 | export default function getLayoutRect(element: HTMLElement): Rect { 8 | const clientRect = getBoundingClientRect(element); 9 | 10 | // Use the clientRect sizes if it's not been transformed. 11 | // Fixes https://github.com/popperjs/popper-core/issues/1223 12 | let width = element.offsetWidth; 13 | let height = element.offsetHeight; 14 | 15 | if (Math.abs(clientRect.width - width) <= 1) { 16 | width = clientRect.width; 17 | } 18 | 19 | if (Math.abs(clientRect.height - height) <= 1) { 20 | height = clientRect.height; 21 | } 22 | 23 | return { 24 | x: element.offsetLeft, 25 | y: element.offsetTop, 26 | width, 27 | height, 28 | }; 29 | } 30 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeName.d.ts: -------------------------------------------------------------------------------- 1 | import type { Window } from "../types"; 2 | export default function getNodeName(element: (Node | null | undefined) | Window): string | null | undefined; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeName.js: -------------------------------------------------------------------------------- 1 | export default function getNodeName(element) { 2 | return element ? (element.nodeName || '').toLowerCase() : null; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeName.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Window } from '../types'; 3 | 4 | export default function getNodeName(element: ?Node | Window): ?string { 5 | return element ? (element.nodeName || '').toLowerCase() : null; 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.d.ts: -------------------------------------------------------------------------------- 1 | import type { Window } from "../types"; 2 | export default function getNodeScroll(node: Node | Window): { 3 | scrollLeft: any; 4 | scrollTop: any; 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js: -------------------------------------------------------------------------------- 1 | import getWindowScroll from "./getWindowScroll.js"; 2 | import getWindow from "./getWindow.js"; 3 | import { isHTMLElement } from "./instanceOf.js"; 4 | import getHTMLElementScroll from "./getHTMLElementScroll.js"; 5 | export default function getNodeScroll(node) { 6 | if (node === getWindow(node) || !isHTMLElement(node)) { 7 | return getWindowScroll(node); 8 | } else { 9 | return getHTMLElementScroll(node); 10 | } 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getWindowScroll from './getWindowScroll'; 3 | import getWindow from './getWindow'; 4 | import { isHTMLElement } from './instanceOf'; 5 | import getHTMLElementScroll from './getHTMLElementScroll'; 6 | import type { Window } from '../types'; 7 | 8 | export default function getNodeScroll(node: Node | Window) { 9 | if (node === getWindow(node) || !isHTMLElement(node)) { 10 | return getWindowScroll(node); 11 | } else { 12 | return getHTMLElementScroll(node); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.d.ts: -------------------------------------------------------------------------------- 1 | export default function getOffsetParent(element: Element): any; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getParentNode.d.ts: -------------------------------------------------------------------------------- 1 | export default function getParentNode(element: Node | ShadowRoot): Node; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getParentNode.js: -------------------------------------------------------------------------------- 1 | import getNodeName from "./getNodeName.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import { isShadowRoot } from "./instanceOf.js"; 4 | export default function getParentNode(element) { 5 | if (getNodeName(element) === 'html') { 6 | return element; 7 | } 8 | 9 | return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 10 | // $FlowFixMe[incompatible-return] 11 | // $FlowFixMe[prop-missing] 12 | element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 13 | element.parentNode || ( // DOM Element detected 14 | isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 15 | // $FlowFixMe[incompatible-call]: HTMLElement is a Node 16 | getDocumentElement(element) // fallback 17 | 18 | ); 19 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getParentNode.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getNodeName from './getNodeName'; 3 | import getDocumentElement from './getDocumentElement'; 4 | import { isShadowRoot } from './instanceOf'; 5 | 6 | export default function getParentNode(element: Node | ShadowRoot): Node { 7 | if (getNodeName(element) === 'html') { 8 | return element; 9 | } 10 | 11 | return ( 12 | // this is a quicker (but less type safe) way to save quite some bytes from the bundle 13 | // $FlowFixMe[incompatible-return] 14 | // $FlowFixMe[prop-missing] 15 | element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 16 | element.parentNode || // DOM Element detected 17 | (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 18 | // $FlowFixMe[incompatible-call]: HTMLElement is a Node 19 | getDocumentElement(element) // fallback 20 | ); 21 | } 22 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getScrollParent.d.ts: -------------------------------------------------------------------------------- 1 | export default function getScrollParent(node: Node): HTMLElement; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js: -------------------------------------------------------------------------------- 1 | import getParentNode from "./getParentNode.js"; 2 | import isScrollParent from "./isScrollParent.js"; 3 | import getNodeName from "./getNodeName.js"; 4 | import { isHTMLElement } from "./instanceOf.js"; 5 | export default function getScrollParent(node) { 6 | if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 7 | // $FlowFixMe[incompatible-return]: assume body is always available 8 | return node.ownerDocument.body; 9 | } 10 | 11 | if (isHTMLElement(node) && isScrollParent(node)) { 12 | return node; 13 | } 14 | 15 | return getScrollParent(getParentNode(node)); 16 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getParentNode from './getParentNode'; 3 | import isScrollParent from './isScrollParent'; 4 | import getNodeName from './getNodeName'; 5 | import { isHTMLElement } from './instanceOf'; 6 | 7 | export default function getScrollParent(node: Node): HTMLElement { 8 | if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 9 | // $FlowFixMe[incompatible-return]: assume body is always available 10 | return node.ownerDocument.body; 11 | } 12 | 13 | if (isHTMLElement(node) && isScrollParent(node)) { 14 | return node; 15 | } 16 | 17 | return getScrollParent(getParentNode(node)); 18 | } 19 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getViewportRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { PositioningStrategy } from "../types"; 2 | export default function getViewportRect(element: Element, strategy: PositioningStrategy): { 3 | width: number; 4 | height: number; 5 | x: number; 6 | y: number; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import getWindowScrollBarX from "./getWindowScrollBarX.js"; 4 | import isLayoutViewport from "./isLayoutViewport.js"; 5 | export default function getViewportRect(element, strategy) { 6 | var win = getWindow(element); 7 | var html = getDocumentElement(element); 8 | var visualViewport = win.visualViewport; 9 | var width = html.clientWidth; 10 | var height = html.clientHeight; 11 | var x = 0; 12 | var y = 0; 13 | 14 | if (visualViewport) { 15 | width = visualViewport.width; 16 | height = visualViewport.height; 17 | var layoutViewport = isLayoutViewport(); 18 | 19 | if (layoutViewport || !layoutViewport && strategy === 'fixed') { 20 | x = visualViewport.offsetLeft; 21 | y = visualViewport.offsetTop; 22 | } 23 | } 24 | 25 | return { 26 | width: width, 27 | height: height, 28 | x: x + getWindowScrollBarX(element), 29 | y: y 30 | }; 31 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getWindow from './getWindow'; 3 | import getDocumentElement from './getDocumentElement'; 4 | import getWindowScrollBarX from './getWindowScrollBarX'; 5 | import isLayoutViewport from './isLayoutViewport'; 6 | import type { PositioningStrategy } from '../types'; 7 | 8 | export default function getViewportRect( 9 | element: Element, 10 | strategy: PositioningStrategy 11 | ) { 12 | const win = getWindow(element); 13 | const html = getDocumentElement(element); 14 | const visualViewport = win.visualViewport; 15 | 16 | let width = html.clientWidth; 17 | let height = html.clientHeight; 18 | let x = 0; 19 | let y = 0; 20 | 21 | if (visualViewport) { 22 | width = visualViewport.width; 23 | height = visualViewport.height; 24 | 25 | const layoutViewport = isLayoutViewport(); 26 | 27 | if (layoutViewport || (!layoutViewport && strategy === 'fixed')) { 28 | x = visualViewport.offsetLeft; 29 | y = visualViewport.offsetTop; 30 | } 31 | } 32 | 33 | return { 34 | width, 35 | height, 36 | x: x + getWindowScrollBarX(element), 37 | y, 38 | }; 39 | } 40 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindow.d.ts: -------------------------------------------------------------------------------- 1 | export default function getWindow(node: any): any; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindow.js: -------------------------------------------------------------------------------- 1 | export default function getWindow(node) { 2 | if (node == null) { 3 | return window; 4 | } 5 | 6 | if (node.toString() !== '[object Window]') { 7 | var ownerDocument = node.ownerDocument; 8 | return ownerDocument ? ownerDocument.defaultView || window : window; 9 | } 10 | 11 | return node; 12 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindow.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Window } from '../types'; 3 | declare function getWindow(node: Node | Window): Window; 4 | 5 | export default function getWindow(node) { 6 | if (node == null) { 7 | return window; 8 | } 9 | 10 | if (node.toString() !== '[object Window]') { 11 | const ownerDocument = node.ownerDocument; 12 | return ownerDocument ? ownerDocument.defaultView || window : window; 13 | } 14 | 15 | return node; 16 | } 17 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.d.ts: -------------------------------------------------------------------------------- 1 | import type { Window } from "../types"; 2 | export default function getWindowScroll(node: Node | Window): { 3 | scrollLeft: any; 4 | scrollTop: any; 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | export default function getWindowScroll(node) { 3 | var win = getWindow(node); 4 | var scrollLeft = win.pageXOffset; 5 | var scrollTop = win.pageYOffset; 6 | return { 7 | scrollLeft: scrollLeft, 8 | scrollTop: scrollTop 9 | }; 10 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getWindow from './getWindow'; 3 | import type { Window } from '../types'; 4 | 5 | export default function getWindowScroll(node: Node | Window) { 6 | const win = getWindow(node); 7 | const scrollLeft = win.pageXOffset; 8 | const scrollTop = win.pageYOffset; 9 | 10 | return { 11 | scrollLeft, 12 | scrollTop, 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.d.ts: -------------------------------------------------------------------------------- 1 | export default function getWindowScrollBarX(element: Element): number; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js: -------------------------------------------------------------------------------- 1 | import getBoundingClientRect from "./getBoundingClientRect.js"; 2 | import getDocumentElement from "./getDocumentElement.js"; 3 | import getWindowScroll from "./getWindowScroll.js"; 4 | export default function getWindowScrollBarX(element) { 5 | // If has a CSS width greater than the viewport, then this will be 6 | // incorrect for RTL. 7 | // Popper 1 is broken in this case and never had a bug report so let's assume 8 | // it's not an issue. I don't think anyone ever specifies width on 9 | // anyway. 10 | // Browsers where the left scrollbar doesn't cause an issue report `0` for 11 | // this (e.g. Edge 2019, IE11, Safari) 12 | return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 13 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getBoundingClientRect from './getBoundingClientRect'; 3 | import getDocumentElement from './getDocumentElement'; 4 | import getWindowScroll from './getWindowScroll'; 5 | 6 | export default function getWindowScrollBarX(element: Element): number { 7 | // If has a CSS width greater than the viewport, then this will be 8 | // incorrect for RTL. 9 | // Popper 1 is broken in this case and never had a bug report so let's assume 10 | // it's not an issue. I don't think anyone ever specifies width on 11 | // anyway. 12 | // Browsers where the left scrollbar doesn't cause an issue report `0` for 13 | // this (e.g. Edge 2019, IE11, Safari) 14 | return ( 15 | getBoundingClientRect(getDocumentElement(element)).left + 16 | getWindowScroll(element).scrollLeft 17 | ); 18 | } 19 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/instanceOf.d.ts: -------------------------------------------------------------------------------- 1 | declare function isElement(node: unknown): boolean; 2 | declare function isHTMLElement(node: unknown): boolean; 3 | declare function isShadowRoot(node: unknown): boolean; 4 | export { isElement, isHTMLElement, isShadowRoot }; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/instanceOf.js: -------------------------------------------------------------------------------- 1 | import getWindow from "./getWindow.js"; 2 | 3 | function isElement(node) { 4 | var OwnElement = getWindow(node).Element; 5 | return node instanceof OwnElement || node instanceof Element; 6 | } 7 | 8 | function isHTMLElement(node) { 9 | var OwnElement = getWindow(node).HTMLElement; 10 | return node instanceof OwnElement || node instanceof HTMLElement; 11 | } 12 | 13 | function isShadowRoot(node) { 14 | // IE 11 has no ShadowRoot 15 | if (typeof ShadowRoot === 'undefined') { 16 | return false; 17 | } 18 | 19 | var OwnElement = getWindow(node).ShadowRoot; 20 | return node instanceof OwnElement || node instanceof ShadowRoot; 21 | } 22 | 23 | export { isElement, isHTMLElement, isShadowRoot }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/instanceOf.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getWindow from './getWindow'; 3 | 4 | declare function isElement(node: mixed): boolean %checks(node instanceof 5 | Element); 6 | function isElement(node) { 7 | const OwnElement = getWindow(node).Element; 8 | return node instanceof OwnElement || node instanceof Element; 9 | } 10 | 11 | declare function isHTMLElement(node: mixed): boolean %checks(node instanceof 12 | HTMLElement); 13 | function isHTMLElement(node) { 14 | const OwnElement = getWindow(node).HTMLElement; 15 | return node instanceof OwnElement || node instanceof HTMLElement; 16 | } 17 | 18 | declare function isShadowRoot(node: mixed): boolean %checks(node instanceof 19 | ShadowRoot); 20 | function isShadowRoot(node) { 21 | // IE 11 has no ShadowRoot 22 | if (typeof ShadowRoot === 'undefined') { 23 | return false; 24 | } 25 | const OwnElement = getWindow(node).ShadowRoot; 26 | return node instanceof OwnElement || node instanceof ShadowRoot; 27 | } 28 | 29 | export { isElement, isHTMLElement, isShadowRoot }; 30 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.d.ts: -------------------------------------------------------------------------------- 1 | export default function isLayoutViewport(): boolean; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js: -------------------------------------------------------------------------------- 1 | import getUAString from "../utils/userAgent.js"; 2 | export default function isLayoutViewport() { 3 | return !/^((?!chrome|android).)*safari/i.test(getUAString()); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getUAString from '../utils/userAgent'; 3 | 4 | export default function isLayoutViewport() { 5 | return !/^((?!chrome|android).)*safari/i.test(getUAString()); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isScrollParent.d.ts: -------------------------------------------------------------------------------- 1 | export default function isScrollParent(element: HTMLElement): boolean; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js: -------------------------------------------------------------------------------- 1 | import getComputedStyle from "./getComputedStyle.js"; 2 | export default function isScrollParent(element) { 3 | // Firefox wants us to check `-x` and `-y` variations as well 4 | var _getComputedStyle = getComputedStyle(element), 5 | overflow = _getComputedStyle.overflow, 6 | overflowX = _getComputedStyle.overflowX, 7 | overflowY = _getComputedStyle.overflowY; 8 | 9 | return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 10 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getComputedStyle from './getComputedStyle'; 3 | 4 | export default function isScrollParent(element: HTMLElement): boolean { 5 | // Firefox wants us to check `-x` and `-y` variations as well 6 | const { overflow, overflowX, overflowY } = getComputedStyle(element); 7 | return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isTableElement.d.ts: -------------------------------------------------------------------------------- 1 | export default function isTableElement(element: Element): boolean; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isTableElement.js: -------------------------------------------------------------------------------- 1 | import getNodeName from "./getNodeName.js"; 2 | export default function isTableElement(element) { 3 | return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/isTableElement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getNodeName from './getNodeName'; 3 | 4 | export default function isTableElement(element: Element): boolean { 5 | return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/listScrollParents.d.ts: -------------------------------------------------------------------------------- 1 | import type { Window, VisualViewport } from "../types"; 2 | export default function listScrollParents(element: Node, list?: Array): Array; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js: -------------------------------------------------------------------------------- 1 | import getScrollParent from "./getScrollParent.js"; 2 | import getParentNode from "./getParentNode.js"; 3 | import getWindow from "./getWindow.js"; 4 | import isScrollParent from "./isScrollParent.js"; 5 | /* 6 | given a DOM element, return the list of all scroll parents, up the list of ancesors 7 | until we get to the top window object. This list is what we attach scroll listeners 8 | to, because if any of these parent elements scroll, we'll need to re-calculate the 9 | reference element's position. 10 | */ 11 | 12 | export default function listScrollParents(element, list) { 13 | var _element$ownerDocumen; 14 | 15 | if (list === void 0) { 16 | list = []; 17 | } 18 | 19 | var scrollParent = getScrollParent(element); 20 | var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 21 | var win = getWindow(scrollParent); 22 | var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 23 | var updatedList = list.concat(target); 24 | return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 25 | updatedList.concat(listScrollParents(getParentNode(target))); 26 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import getScrollParent from './getScrollParent'; 3 | import getParentNode from './getParentNode'; 4 | import getWindow from './getWindow'; 5 | import type { Window, VisualViewport } from '../types'; 6 | import isScrollParent from './isScrollParent'; 7 | 8 | /* 9 | given a DOM element, return the list of all scroll parents, up the list of ancesors 10 | until we get to the top window object. This list is what we attach scroll listeners 11 | to, because if any of these parent elements scroll, we'll need to re-calculate the 12 | reference element's position. 13 | */ 14 | export default function listScrollParents( 15 | element: Node, 16 | list: Array = [] 17 | ): Array { 18 | const scrollParent = getScrollParent(element); 19 | const isBody = scrollParent === element.ownerDocument?.body; 20 | const win = getWindow(scrollParent); 21 | const target = isBody 22 | ? [win].concat( 23 | win.visualViewport || [], 24 | isScrollParent(scrollParent) ? scrollParent : [] 25 | ) 26 | : scrollParent; 27 | const updatedList = list.concat(target); 28 | 29 | return isBody 30 | ? updatedList 31 | : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 32 | updatedList.concat(listScrollParents(getParentNode(target))); 33 | } 34 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/enums.d.ts: -------------------------------------------------------------------------------- 1 | export declare const top: "top"; 2 | export declare const bottom: "bottom"; 3 | export declare const right: "right"; 4 | export declare const left: "left"; 5 | export declare const auto: "auto"; 6 | export declare type BasePlacement = typeof top | typeof bottom | typeof right | typeof left; 7 | export declare const basePlacements: Array; 8 | export declare const start: "start"; 9 | export declare const end: "end"; 10 | export declare type Variation = typeof start | typeof end; 11 | export declare const clippingParents: "clippingParents"; 12 | export declare const viewport: "viewport"; 13 | export declare type Boundary = Element | Array | typeof clippingParents; 14 | export declare type RootBoundary = typeof viewport | "document"; 15 | export declare const popper: "popper"; 16 | export declare const reference: "reference"; 17 | export declare type Context = typeof popper | typeof reference; 18 | export declare type VariationPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end"; 19 | export declare type AutoPlacement = "auto" | "auto-start" | "auto-end"; 20 | export declare type ComputedPlacement = VariationPlacement | BasePlacement; 21 | export declare type Placement = AutoPlacement | BasePlacement | VariationPlacement; 22 | export declare const variationPlacements: Array; 23 | export declare const placements: Array; 24 | export declare const beforeRead: "beforeRead"; 25 | export declare const read: "read"; 26 | export declare const afterRead: "afterRead"; 27 | export declare const beforeMain: "beforeMain"; 28 | export declare const main: "main"; 29 | export declare const afterMain: "afterMain"; 30 | export declare const beforeWrite: "beforeWrite"; 31 | export declare const write: "write"; 32 | export declare const afterWrite: "afterWrite"; 33 | export declare const modifierPhases: Array; 34 | export declare type ModifierPhases = typeof beforeRead | typeof read | typeof afterRead | typeof beforeMain | typeof main | typeof afterMain | typeof beforeWrite | typeof write | typeof afterWrite; 35 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/enums.js: -------------------------------------------------------------------------------- 1 | export var top = 'top'; 2 | export var bottom = 'bottom'; 3 | export var right = 'right'; 4 | export var left = 'left'; 5 | export var auto = 'auto'; 6 | export var basePlacements = [top, bottom, right, left]; 7 | export var start = 'start'; 8 | export var end = 'end'; 9 | export var clippingParents = 'clippingParents'; 10 | export var viewport = 'viewport'; 11 | export var popper = 'popper'; 12 | export var reference = 'reference'; 13 | export var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 14 | return acc.concat([placement + "-" + start, placement + "-" + end]); 15 | }, []); 16 | export var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 17 | return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 18 | }, []); // modifiers that need to read the DOM 19 | 20 | export var beforeRead = 'beforeRead'; 21 | export var read = 'read'; 22 | export var afterRead = 'afterRead'; // pure-logic modifiers 23 | 24 | export var beforeMain = 'beforeMain'; 25 | export var main = 'main'; 26 | export var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 27 | 28 | export var beforeWrite = 'beforeWrite'; 29 | export var write = 'write'; 30 | export var afterWrite = 'afterWrite'; 31 | export var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/index.d.ts: -------------------------------------------------------------------------------- 1 | export * from "./types"; 2 | export * from "./enums"; 3 | export * from "./modifiers"; 4 | export { popperGenerator, detectOverflow, createPopper as createPopperBase } from "./createPopper"; 5 | export { createPopper } from "./popper"; 6 | export { createPopper as createPopperLite } from "./popper-lite"; 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/index.js: -------------------------------------------------------------------------------- 1 | export * from "./enums.js"; 2 | export * from "./modifiers/index.js"; // eslint-disable-next-line import/no-unused-modules 3 | 4 | export { popperGenerator, detectOverflow, createPopper as createPopperBase } from "./createPopper.js"; // eslint-disable-next-line import/no-unused-modules 5 | 6 | export { createPopper } from "./popper.js"; // eslint-disable-next-line import/no-unused-modules 7 | 8 | export { createPopper as createPopperLite } from "./popper-lite.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/index.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | export type * from './types'; 3 | export * from './enums'; 4 | export * from './modifiers'; 5 | 6 | // eslint-disable-next-line import/no-unused-modules 7 | export { popperGenerator, detectOverflow, createPopper as createPopperBase } from './createPopper'; 8 | 9 | // eslint-disable-next-line import/no-unused-modules 10 | export { createPopper } from './popper'; 11 | 12 | // eslint-disable-next-line import/no-unused-modules 13 | export { createPopper as createPopperLite } from './popper-lite'; 14 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/applyStyles.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export declare type ApplyStylesModifier = Modifier<"applyStyles", {}>; 3 | declare const _default: ApplyStylesModifier; 4 | export default _default; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/arrow.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier, Padding, Rect } from "../types"; 2 | import type { Placement } from "../enums"; 3 | export declare type Options = { 4 | element: HTMLElement | string | null; 5 | padding: Padding | ((arg0: { 6 | popper: Rect; 7 | reference: Rect; 8 | placement: Placement; 9 | }) => Padding); 10 | }; 11 | export declare type ArrowModifier = Modifier<"arrow", Options>; 12 | declare const _default: ArrowModifier; 13 | export default _default; 14 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/computeStyles.d.ts: -------------------------------------------------------------------------------- 1 | import type { PositioningStrategy, Offsets, Modifier, Rect } from "../types"; 2 | import { BasePlacement, Variation } from "../enums"; 3 | export declare type RoundOffsets = (offsets: Partial<{ 4 | x: number; 5 | y: number; 6 | centerOffset: number; 7 | }>) => Offsets; 8 | export declare type Options = { 9 | gpuAcceleration: boolean; 10 | adaptive: boolean; 11 | roundOffsets?: boolean | RoundOffsets; 12 | }; 13 | export declare function mapToStyles({ popper, popperRect, placement, variation, offsets, position, gpuAcceleration, adaptive, roundOffsets, isFixed }: { 14 | popper: HTMLElement; 15 | popperRect: Rect; 16 | placement: BasePlacement; 17 | variation: Variation | null | undefined; 18 | offsets: Partial<{ 19 | x: number; 20 | y: number; 21 | centerOffset: number; 22 | }>; 23 | position: PositioningStrategy; 24 | gpuAcceleration: boolean; 25 | adaptive: boolean; 26 | roundOffsets: boolean | RoundOffsets; 27 | isFixed: boolean; 28 | }): { 29 | transform: string; 30 | top: string; 31 | right: string; 32 | bottom: string; 33 | left: string; 34 | position: PositioningStrategy; 35 | }; 36 | export declare type ComputeStylesModifier = Modifier<"computeStyles", Options>; 37 | declare const _default: ComputeStylesModifier; 38 | export default _default; 39 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/eventListeners.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export declare type Options = { 3 | scroll: boolean; 4 | resize: boolean; 5 | }; 6 | export declare type EventListenersModifier = Modifier<"eventListeners", Options>; 7 | declare const _default: EventListenersModifier; 8 | export default _default; 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/eventListeners.js: -------------------------------------------------------------------------------- 1 | import getWindow from "../dom-utils/getWindow.js"; // eslint-disable-next-line import/no-unused-modules 2 | 3 | var passive = { 4 | passive: true 5 | }; 6 | 7 | function effect(_ref) { 8 | var state = _ref.state, 9 | instance = _ref.instance, 10 | options = _ref.options; 11 | var _options$scroll = options.scroll, 12 | scroll = _options$scroll === void 0 ? true : _options$scroll, 13 | _options$resize = options.resize, 14 | resize = _options$resize === void 0 ? true : _options$resize; 15 | var window = getWindow(state.elements.popper); 16 | var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 17 | 18 | if (scroll) { 19 | scrollParents.forEach(function (scrollParent) { 20 | scrollParent.addEventListener('scroll', instance.update, passive); 21 | }); 22 | } 23 | 24 | if (resize) { 25 | window.addEventListener('resize', instance.update, passive); 26 | } 27 | 28 | return function () { 29 | if (scroll) { 30 | scrollParents.forEach(function (scrollParent) { 31 | scrollParent.removeEventListener('scroll', instance.update, passive); 32 | }); 33 | } 34 | 35 | if (resize) { 36 | window.removeEventListener('resize', instance.update, passive); 37 | } 38 | }; 39 | } // eslint-disable-next-line import/no-unused-modules 40 | 41 | 42 | export default { 43 | name: 'eventListeners', 44 | enabled: true, 45 | phase: 'write', 46 | fn: function fn() {}, 47 | effect: effect, 48 | data: {} 49 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/eventListeners.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { ModifierArguments, Modifier } from '../types'; 3 | import getWindow from '../dom-utils/getWindow'; 4 | 5 | // eslint-disable-next-line import/no-unused-modules 6 | export type Options = { 7 | scroll: boolean, 8 | resize: boolean, 9 | }; 10 | 11 | const passive = { passive: true }; 12 | 13 | function effect({ state, instance, options }: ModifierArguments) { 14 | const { scroll = true, resize = true } = options; 15 | 16 | const window = getWindow(state.elements.popper); 17 | const scrollParents = [ 18 | ...state.scrollParents.reference, 19 | ...state.scrollParents.popper, 20 | ]; 21 | 22 | if (scroll) { 23 | scrollParents.forEach(scrollParent => { 24 | scrollParent.addEventListener('scroll', instance.update, passive); 25 | }); 26 | } 27 | 28 | if (resize) { 29 | window.addEventListener('resize', instance.update, passive); 30 | } 31 | 32 | return () => { 33 | if (scroll) { 34 | scrollParents.forEach(scrollParent => { 35 | scrollParent.removeEventListener('scroll', instance.update, passive); 36 | }); 37 | } 38 | 39 | if (resize) { 40 | window.removeEventListener('resize', instance.update, passive); 41 | } 42 | }; 43 | } 44 | 45 | // eslint-disable-next-line import/no-unused-modules 46 | export type EventListenersModifier = Modifier<'eventListeners', Options>; 47 | export default ({ 48 | name: 'eventListeners', 49 | enabled: true, 50 | phase: 'write', 51 | fn: () => {}, 52 | effect, 53 | data: {}, 54 | }: EventListenersModifier); 55 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/flip.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement, Boundary, RootBoundary } from "../enums"; 2 | import type { Modifier, Padding } from "../types"; 3 | export declare type Options = { 4 | mainAxis: boolean; 5 | altAxis: boolean; 6 | fallbackPlacements: Array; 7 | padding: Padding; 8 | boundary: Boundary; 9 | rootBoundary: RootBoundary; 10 | altBoundary: boolean; 11 | flipVariations: boolean; 12 | allowedAutoPlacements: Array; 13 | }; 14 | export declare type FlipModifier = Modifier<"flip", Options>; 15 | declare const _default: FlipModifier; 16 | export default _default; 17 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/hide.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export declare type HideModifier = Modifier<"hide", {}>; 3 | declare const _default: HideModifier; 4 | export default _default; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/hide.js: -------------------------------------------------------------------------------- 1 | import { top, bottom, left, right } from "../enums.js"; 2 | import detectOverflow from "../utils/detectOverflow.js"; 3 | 4 | function getSideOffsets(overflow, rect, preventedOffsets) { 5 | if (preventedOffsets === void 0) { 6 | preventedOffsets = { 7 | x: 0, 8 | y: 0 9 | }; 10 | } 11 | 12 | return { 13 | top: overflow.top - rect.height - preventedOffsets.y, 14 | right: overflow.right - rect.width + preventedOffsets.x, 15 | bottom: overflow.bottom - rect.height + preventedOffsets.y, 16 | left: overflow.left - rect.width - preventedOffsets.x 17 | }; 18 | } 19 | 20 | function isAnySideFullyClipped(overflow) { 21 | return [top, right, bottom, left].some(function (side) { 22 | return overflow[side] >= 0; 23 | }); 24 | } 25 | 26 | function hide(_ref) { 27 | var state = _ref.state, 28 | name = _ref.name; 29 | var referenceRect = state.rects.reference; 30 | var popperRect = state.rects.popper; 31 | var preventedOffsets = state.modifiersData.preventOverflow; 32 | var referenceOverflow = detectOverflow(state, { 33 | elementContext: 'reference' 34 | }); 35 | var popperAltOverflow = detectOverflow(state, { 36 | altBoundary: true 37 | }); 38 | var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 39 | var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 40 | var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 41 | var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 42 | state.modifiersData[name] = { 43 | referenceClippingOffsets: referenceClippingOffsets, 44 | popperEscapeOffsets: popperEscapeOffsets, 45 | isReferenceHidden: isReferenceHidden, 46 | hasPopperEscaped: hasPopperEscaped 47 | }; 48 | state.attributes.popper = Object.assign({}, state.attributes.popper, { 49 | 'data-popper-reference-hidden': isReferenceHidden, 50 | 'data-popper-escaped': hasPopperEscaped 51 | }); 52 | } // eslint-disable-next-line import/no-unused-modules 53 | 54 | 55 | export default { 56 | name: 'hide', 57 | enabled: true, 58 | phase: 'main', 59 | requiresIfExists: ['preventOverflow'], 60 | fn: hide 61 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/index.d.ts: -------------------------------------------------------------------------------- 1 | export { default as applyStyles } from "./applyStyles"; 2 | export { default as arrow } from "./arrow"; 3 | export { default as computeStyles } from "./computeStyles"; 4 | export { default as eventListeners } from "./eventListeners"; 5 | export { default as flip } from "./flip"; 6 | export { default as hide } from "./hide"; 7 | export { default as offset } from "./offset"; 8 | export { default as popperOffsets } from "./popperOffsets"; 9 | export { default as preventOverflow } from "./preventOverflow"; 10 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/index.js: -------------------------------------------------------------------------------- 1 | export { default as applyStyles } from "./applyStyles.js"; 2 | export { default as arrow } from "./arrow.js"; 3 | export { default as computeStyles } from "./computeStyles.js"; 4 | export { default as eventListeners } from "./eventListeners.js"; 5 | export { default as flip } from "./flip.js"; 6 | export { default as hide } from "./hide.js"; 7 | export { default as offset } from "./offset.js"; 8 | export { default as popperOffsets } from "./popperOffsets.js"; 9 | export { default as preventOverflow } from "./preventOverflow.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/index.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | export { default as applyStyles } from './applyStyles'; 3 | export { default as arrow } from './arrow'; 4 | export { default as computeStyles } from './computeStyles'; 5 | export { default as eventListeners } from './eventListeners'; 6 | export { default as flip } from './flip'; 7 | export { default as hide } from './hide'; 8 | export { default as offset } from './offset'; 9 | export { default as popperOffsets } from './popperOffsets'; 10 | export { default as preventOverflow } from './preventOverflow'; 11 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/offset.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement } from "../enums"; 2 | import type { Modifier, Rect, Offsets } from "../types"; 3 | export declare type OffsetsFunction = (arg0: { 4 | popper: Rect; 5 | reference: Rect; 6 | placement: Placement; 7 | }) => [number | null | undefined, number | null | undefined]; 8 | declare type Offset = OffsetsFunction | [number | null | undefined, number | null | undefined]; 9 | export declare type Options = { 10 | offset: Offset; 11 | }; 12 | export declare function distanceAndSkiddingToXY(placement: Placement, rects: { 13 | popper: Rect; 14 | reference: Rect; 15 | }, offset: Offset): Offsets; 16 | export declare type OffsetModifier = Modifier<"offset", Options>; 17 | declare const _default: OffsetModifier; 18 | export default _default; 19 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/offset.js: -------------------------------------------------------------------------------- 1 | import getBasePlacement from "../utils/getBasePlacement.js"; 2 | import { top, left, right, placements } from "../enums.js"; // eslint-disable-next-line import/no-unused-modules 3 | 4 | export function distanceAndSkiddingToXY(placement, rects, offset) { 5 | var basePlacement = getBasePlacement(placement); 6 | var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 7 | 8 | var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 9 | placement: placement 10 | })) : offset, 11 | skidding = _ref[0], 12 | distance = _ref[1]; 13 | 14 | skidding = skidding || 0; 15 | distance = (distance || 0) * invertDistance; 16 | return [left, right].indexOf(basePlacement) >= 0 ? { 17 | x: distance, 18 | y: skidding 19 | } : { 20 | x: skidding, 21 | y: distance 22 | }; 23 | } 24 | 25 | function offset(_ref2) { 26 | var state = _ref2.state, 27 | options = _ref2.options, 28 | name = _ref2.name; 29 | var _options$offset = options.offset, 30 | offset = _options$offset === void 0 ? [0, 0] : _options$offset; 31 | var data = placements.reduce(function (acc, placement) { 32 | acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 33 | return acc; 34 | }, {}); 35 | var _data$state$placement = data[state.placement], 36 | x = _data$state$placement.x, 37 | y = _data$state$placement.y; 38 | 39 | if (state.modifiersData.popperOffsets != null) { 40 | state.modifiersData.popperOffsets.x += x; 41 | state.modifiersData.popperOffsets.y += y; 42 | } 43 | 44 | state.modifiersData[name] = data; 45 | } // eslint-disable-next-line import/no-unused-modules 46 | 47 | 48 | export default { 49 | name: 'offset', 50 | enabled: true, 51 | phase: 'main', 52 | requires: ['popperOffsets'], 53 | fn: offset 54 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/offset.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Placement } from '../enums'; 3 | import type { ModifierArguments, Modifier, Rect, Offsets } from '../types'; 4 | import getBasePlacement from '../utils/getBasePlacement'; 5 | import { top, left, right, placements } from '../enums'; 6 | 7 | // eslint-disable-next-line import/no-unused-modules 8 | export type OffsetsFunction = ({ 9 | popper: Rect, 10 | reference: Rect, 11 | placement: Placement, 12 | }) => [?number, ?number]; 13 | 14 | type Offset = OffsetsFunction | [?number, ?number]; 15 | 16 | // eslint-disable-next-line import/no-unused-modules 17 | export type Options = { 18 | offset: Offset, 19 | }; 20 | 21 | export function distanceAndSkiddingToXY( 22 | placement: Placement, 23 | rects: { popper: Rect, reference: Rect }, 24 | offset: Offset 25 | ): Offsets { 26 | const basePlacement = getBasePlacement(placement); 27 | const invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 28 | 29 | let [skidding, distance] = 30 | typeof offset === 'function' 31 | ? offset({ 32 | ...rects, 33 | placement, 34 | }) 35 | : offset; 36 | 37 | skidding = skidding || 0; 38 | distance = (distance || 0) * invertDistance; 39 | 40 | return [left, right].indexOf(basePlacement) >= 0 41 | ? { x: distance, y: skidding } 42 | : { x: skidding, y: distance }; 43 | } 44 | 45 | function offset({ state, options, name }: ModifierArguments) { 46 | const { offset = [0, 0] } = options; 47 | 48 | const data = placements.reduce((acc, placement) => { 49 | acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 50 | return acc; 51 | }, {}); 52 | 53 | const { x, y } = data[state.placement]; 54 | 55 | if (state.modifiersData.popperOffsets != null) { 56 | state.modifiersData.popperOffsets.x += x; 57 | state.modifiersData.popperOffsets.y += y; 58 | } 59 | 60 | state.modifiersData[name] = data; 61 | } 62 | 63 | // eslint-disable-next-line import/no-unused-modules 64 | export type OffsetModifier = Modifier<'offset', Options>; 65 | export default ({ 66 | name: 'offset', 67 | enabled: true, 68 | phase: 'main', 69 | requires: ['popperOffsets'], 70 | fn: offset, 71 | }: OffsetModifier); 72 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/popperOffsets.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export declare type PopperOffsetsModifier = Modifier<"popperOffsets", {}>; 3 | declare const _default: PopperOffsetsModifier; 4 | export default _default; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/popperOffsets.js: -------------------------------------------------------------------------------- 1 | import computeOffsets from "../utils/computeOffsets.js"; 2 | 3 | function popperOffsets(_ref) { 4 | var state = _ref.state, 5 | name = _ref.name; 6 | // Offsets are the actual position the popper needs to have to be 7 | // properly positioned near its reference element 8 | // This is the most basic placement, and will be adjusted by 9 | // the modifiers in the next step 10 | state.modifiersData[name] = computeOffsets({ 11 | reference: state.rects.reference, 12 | element: state.rects.popper, 13 | strategy: 'absolute', 14 | placement: state.placement 15 | }); 16 | } // eslint-disable-next-line import/no-unused-modules 17 | 18 | 19 | export default { 20 | name: 'popperOffsets', 21 | enabled: true, 22 | phase: 'read', 23 | fn: popperOffsets, 24 | data: {} 25 | }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/popperOffsets.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { ModifierArguments, Modifier } from '../types'; 3 | import computeOffsets from '../utils/computeOffsets'; 4 | 5 | function popperOffsets({ state, name }: ModifierArguments<{||}>) { 6 | // Offsets are the actual position the popper needs to have to be 7 | // properly positioned near its reference element 8 | // This is the most basic placement, and will be adjusted by 9 | // the modifiers in the next step 10 | state.modifiersData[name] = computeOffsets({ 11 | reference: state.rects.reference, 12 | element: state.rects.popper, 13 | strategy: 'absolute', 14 | placement: state.placement, 15 | }); 16 | } 17 | 18 | // eslint-disable-next-line import/no-unused-modules 19 | export type PopperOffsetsModifier = Modifier<'popperOffsets', {||}>; 20 | export default ({ 21 | name: 'popperOffsets', 22 | enabled: true, 23 | phase: 'read', 24 | fn: popperOffsets, 25 | data: {}, 26 | }: PopperOffsetsModifier); 27 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/modifiers/preventOverflow.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement, Boundary, RootBoundary } from "../enums"; 2 | import type { Rect, Modifier, Padding } from "../types"; 3 | declare type TetherOffset = ((arg0: { 4 | popper: Rect; 5 | reference: Rect; 6 | placement: Placement; 7 | }) => number | { 8 | mainAxis: number; 9 | altAxis: number; 10 | }) | number | { 11 | mainAxis: number; 12 | altAxis: number; 13 | }; 14 | export declare type Options = { 15 | mainAxis: boolean; 16 | altAxis: boolean; 17 | boundary: Boundary; 18 | rootBoundary: RootBoundary; 19 | altBoundary: boolean; 20 | /** 21 | * Allows the popper to overflow from its boundaries to keep it near its 22 | * reference element 23 | */ 24 | tether: boolean; 25 | tetherOffset: TetherOffset; 26 | padding: Padding; 27 | }; 28 | export declare type PreventOverflowModifier = Modifier<"preventOverflow", Options>; 29 | declare const _default: PreventOverflowModifier; 30 | export default _default; 31 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-base.d.ts: -------------------------------------------------------------------------------- 1 | import { createPopper, popperGenerator, detectOverflow } from "./createPopper"; 2 | export * from "./types"; 3 | export { createPopper, popperGenerator, detectOverflow }; 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-base.js: -------------------------------------------------------------------------------- 1 | import { createPopper, popperGenerator, detectOverflow } from "./createPopper.js"; 2 | // eslint-disable-next-line import/no-unused-modules 3 | export { createPopper, popperGenerator, detectOverflow }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-base.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { createPopper, popperGenerator, detectOverflow } from './createPopper'; 3 | 4 | export type * from './types'; 5 | 6 | // eslint-disable-next-line import/no-unused-modules 7 | export { createPopper, popperGenerator, detectOverflow }; 8 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-lite.d.ts: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper"; 2 | export * from "./types"; 3 | declare const defaultModifiers: (import("./modifiers/popperOffsets").PopperOffsetsModifier | import("./modifiers/eventListeners").EventListenersModifier | import("./modifiers/computeStyles").ComputeStylesModifier | import("./modifiers/applyStyles").ApplyStylesModifier)[]; 4 | declare const createPopper: >>(reference: Element | import("./types").VirtualElement, popper: HTMLElement, options?: Partial>) => import("./types").Instance; 5 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; 6 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-lite.js: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper.js"; 2 | import eventListeners from "./modifiers/eventListeners.js"; 3 | import popperOffsets from "./modifiers/popperOffsets.js"; 4 | import computeStyles from "./modifiers/computeStyles.js"; 5 | import applyStyles from "./modifiers/applyStyles.js"; 6 | var defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles]; 7 | var createPopper = /*#__PURE__*/popperGenerator({ 8 | defaultModifiers: defaultModifiers 9 | }); // eslint-disable-next-line import/no-unused-modules 10 | 11 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper-lite.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { popperGenerator, detectOverflow } from './createPopper'; 3 | 4 | import eventListeners from './modifiers/eventListeners'; 5 | import popperOffsets from './modifiers/popperOffsets'; 6 | import computeStyles from './modifiers/computeStyles'; 7 | import applyStyles from './modifiers/applyStyles'; 8 | 9 | export type * from './types'; 10 | 11 | const defaultModifiers = [ 12 | eventListeners, 13 | popperOffsets, 14 | computeStyles, 15 | applyStyles, 16 | ]; 17 | 18 | const createPopper = popperGenerator({ defaultModifiers }); 19 | 20 | // eslint-disable-next-line import/no-unused-modules 21 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; 22 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper.d.ts: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper"; 2 | export * from "./types"; 3 | declare const defaultModifiers: (import("./modifiers/popperOffsets").PopperOffsetsModifier | import("./modifiers/flip").FlipModifier | import("./modifiers/hide").HideModifier | import("./modifiers/offset").OffsetModifier | import("./modifiers/eventListeners").EventListenersModifier | import("./modifiers/computeStyles").ComputeStylesModifier | import("./modifiers/arrow").ArrowModifier | import("./modifiers/preventOverflow").PreventOverflowModifier | import("./modifiers/applyStyles").ApplyStylesModifier)[]; 4 | declare const createPopper: >>(reference: Element | import("./types").VirtualElement, popper: HTMLElement, options?: Partial>) => import("./types").Instance; 5 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; 6 | export { createPopper as createPopperLite } from "./popper-lite"; 7 | export * from "./modifiers"; 8 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper.js: -------------------------------------------------------------------------------- 1 | import { popperGenerator, detectOverflow } from "./createPopper.js"; 2 | import eventListeners from "./modifiers/eventListeners.js"; 3 | import popperOffsets from "./modifiers/popperOffsets.js"; 4 | import computeStyles from "./modifiers/computeStyles.js"; 5 | import applyStyles from "./modifiers/applyStyles.js"; 6 | import offset from "./modifiers/offset.js"; 7 | import flip from "./modifiers/flip.js"; 8 | import preventOverflow from "./modifiers/preventOverflow.js"; 9 | import arrow from "./modifiers/arrow.js"; 10 | import hide from "./modifiers/hide.js"; 11 | var defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles, offset, flip, preventOverflow, arrow, hide]; 12 | var createPopper = /*#__PURE__*/popperGenerator({ 13 | defaultModifiers: defaultModifiers 14 | }); // eslint-disable-next-line import/no-unused-modules 15 | 16 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; // eslint-disable-next-line import/no-unused-modules 17 | 18 | export { createPopper as createPopperLite } from "./popper-lite.js"; // eslint-disable-next-line import/no-unused-modules 19 | 20 | export * from "./modifiers/index.js"; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/popper.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { popperGenerator, detectOverflow } from './createPopper'; 3 | 4 | import eventListeners from './modifiers/eventListeners'; 5 | import popperOffsets from './modifiers/popperOffsets'; 6 | import computeStyles from './modifiers/computeStyles'; 7 | import applyStyles from './modifiers/applyStyles'; 8 | import offset from './modifiers/offset'; 9 | import flip from './modifiers/flip'; 10 | import preventOverflow from './modifiers/preventOverflow'; 11 | import arrow from './modifiers/arrow'; 12 | import hide from './modifiers/hide'; 13 | 14 | export type * from './types'; 15 | 16 | const defaultModifiers = [ 17 | eventListeners, 18 | popperOffsets, 19 | computeStyles, 20 | applyStyles, 21 | offset, 22 | flip, 23 | preventOverflow, 24 | arrow, 25 | hide, 26 | ]; 27 | 28 | const createPopper = popperGenerator({ defaultModifiers }); 29 | 30 | // eslint-disable-next-line import/no-unused-modules 31 | export { createPopper, popperGenerator, defaultModifiers, detectOverflow }; 32 | // eslint-disable-next-line import/no-unused-modules 33 | export { createPopper as createPopperLite } from './popper-lite'; 34 | // eslint-disable-next-line import/no-unused-modules 35 | export * from './modifiers'; 36 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/types.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ginhenrick/CV-bootstrap/16acb4b55478f33b0ff435284b68e6ce4a561d87/node_modules/@popperjs/core/lib/types.js -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/computeAutoPlacement.d.ts: -------------------------------------------------------------------------------- 1 | import type { State, Padding } from "../types"; 2 | import type { Placement, ComputedPlacement, Boundary, RootBoundary } from "../enums"; 3 | declare type Options = { 4 | placement: Placement; 5 | padding: Padding; 6 | boundary: Boundary; 7 | rootBoundary: RootBoundary; 8 | flipVariations: boolean; 9 | allowedAutoPlacements?: Array; 10 | }; 11 | export default function computeAutoPlacement(state: Partial, options?: Options): Array; 12 | export {}; 13 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js: -------------------------------------------------------------------------------- 1 | import getVariation from "./getVariation.js"; 2 | import { variationPlacements, basePlacements, placements as allPlacements } from "../enums.js"; 3 | import detectOverflow from "./detectOverflow.js"; 4 | import getBasePlacement from "./getBasePlacement.js"; 5 | export default function computeAutoPlacement(state, options) { 6 | if (options === void 0) { 7 | options = {}; 8 | } 9 | 10 | var _options = options, 11 | placement = _options.placement, 12 | boundary = _options.boundary, 13 | rootBoundary = _options.rootBoundary, 14 | padding = _options.padding, 15 | flipVariations = _options.flipVariations, 16 | _options$allowedAutoP = _options.allowedAutoPlacements, 17 | allowedAutoPlacements = _options$allowedAutoP === void 0 ? allPlacements : _options$allowedAutoP; 18 | var variation = getVariation(placement); 19 | var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 20 | return getVariation(placement) === variation; 21 | }) : basePlacements; 22 | var allowedPlacements = placements.filter(function (placement) { 23 | return allowedAutoPlacements.indexOf(placement) >= 0; 24 | }); 25 | 26 | if (allowedPlacements.length === 0) { 27 | allowedPlacements = placements; 28 | } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 29 | 30 | 31 | var overflows = allowedPlacements.reduce(function (acc, placement) { 32 | acc[placement] = detectOverflow(state, { 33 | placement: placement, 34 | boundary: boundary, 35 | rootBoundary: rootBoundary, 36 | padding: padding 37 | })[getBasePlacement(placement)]; 38 | return acc; 39 | }, {}); 40 | return Object.keys(overflows).sort(function (a, b) { 41 | return overflows[a] - overflows[b]; 42 | }); 43 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { State, Padding } from '../types'; 3 | import type { 4 | Placement, 5 | ComputedPlacement, 6 | Boundary, 7 | RootBoundary, 8 | } from '../enums'; 9 | import getVariation from './getVariation'; 10 | import { 11 | variationPlacements, 12 | basePlacements, 13 | placements as allPlacements, 14 | } from '../enums'; 15 | import detectOverflow from './detectOverflow'; 16 | import getBasePlacement from './getBasePlacement'; 17 | 18 | type Options = { 19 | placement: Placement, 20 | padding: Padding, 21 | boundary: Boundary, 22 | rootBoundary: RootBoundary, 23 | flipVariations: boolean, 24 | allowedAutoPlacements?: Array, 25 | }; 26 | 27 | type OverflowsMap = { [ComputedPlacement]: number }; 28 | 29 | export default function computeAutoPlacement( 30 | state: $Shape, 31 | options: Options = {} 32 | ): Array { 33 | const { 34 | placement, 35 | boundary, 36 | rootBoundary, 37 | padding, 38 | flipVariations, 39 | allowedAutoPlacements = allPlacements, 40 | } = options; 41 | 42 | const variation = getVariation(placement); 43 | 44 | const placements = variation 45 | ? flipVariations 46 | ? variationPlacements 47 | : variationPlacements.filter( 48 | (placement) => getVariation(placement) === variation 49 | ) 50 | : basePlacements; 51 | 52 | let allowedPlacements = placements.filter( 53 | (placement) => allowedAutoPlacements.indexOf(placement) >= 0 54 | ); 55 | 56 | if (allowedPlacements.length === 0) { 57 | allowedPlacements = placements; 58 | } 59 | 60 | // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 61 | const overflows: OverflowsMap = allowedPlacements.reduce((acc, placement) => { 62 | acc[placement] = detectOverflow(state, { 63 | placement, 64 | boundary, 65 | rootBoundary, 66 | padding, 67 | })[getBasePlacement(placement)]; 68 | 69 | return acc; 70 | }, {}); 71 | 72 | return Object.keys(overflows).sort((a, b) => overflows[a] - overflows[b]); 73 | } 74 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/computeOffsets.d.ts: -------------------------------------------------------------------------------- 1 | import type { Rect, PositioningStrategy, Offsets, ClientRectObject } from "../types"; 2 | import { Placement } from "../enums"; 3 | export default function computeOffsets({ reference, element, placement }: { 4 | reference: Rect | ClientRectObject; 5 | element: Rect | ClientRectObject; 6 | strategy: PositioningStrategy; 7 | placement?: Placement; 8 | }): Offsets; 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/computeOffsets.js: -------------------------------------------------------------------------------- 1 | import getBasePlacement from "./getBasePlacement.js"; 2 | import getVariation from "./getVariation.js"; 3 | import getMainAxisFromPlacement from "./getMainAxisFromPlacement.js"; 4 | import { top, right, bottom, left, start, end } from "../enums.js"; 5 | export default function computeOffsets(_ref) { 6 | var reference = _ref.reference, 7 | element = _ref.element, 8 | placement = _ref.placement; 9 | var basePlacement = placement ? getBasePlacement(placement) : null; 10 | var variation = placement ? getVariation(placement) : null; 11 | var commonX = reference.x + reference.width / 2 - element.width / 2; 12 | var commonY = reference.y + reference.height / 2 - element.height / 2; 13 | var offsets; 14 | 15 | switch (basePlacement) { 16 | case top: 17 | offsets = { 18 | x: commonX, 19 | y: reference.y - element.height 20 | }; 21 | break; 22 | 23 | case bottom: 24 | offsets = { 25 | x: commonX, 26 | y: reference.y + reference.height 27 | }; 28 | break; 29 | 30 | case right: 31 | offsets = { 32 | x: reference.x + reference.width, 33 | y: commonY 34 | }; 35 | break; 36 | 37 | case left: 38 | offsets = { 39 | x: reference.x - element.width, 40 | y: commonY 41 | }; 42 | break; 43 | 44 | default: 45 | offsets = { 46 | x: reference.x, 47 | y: reference.y 48 | }; 49 | } 50 | 51 | var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 52 | 53 | if (mainAxis != null) { 54 | var len = mainAxis === 'y' ? 'height' : 'width'; 55 | 56 | switch (variation) { 57 | case start: 58 | offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 59 | break; 60 | 61 | case end: 62 | offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 63 | break; 64 | 65 | default: 66 | } 67 | } 68 | 69 | return offsets; 70 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/debounce.d.ts: -------------------------------------------------------------------------------- 1 | export default function debounce(fn: (...args: Array) => any): () => Promise; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/debounce.js: -------------------------------------------------------------------------------- 1 | export default function debounce(fn) { 2 | var pending; 3 | return function () { 4 | if (!pending) { 5 | pending = new Promise(function (resolve) { 6 | Promise.resolve().then(function () { 7 | pending = undefined; 8 | resolve(fn()); 9 | }); 10 | }); 11 | } 12 | 13 | return pending; 14 | }; 15 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/debounce.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function debounce(fn: Function): () => Promise { 4 | let pending; 5 | return () => { 6 | if (!pending) { 7 | pending = new Promise(resolve => { 8 | Promise.resolve().then(() => { 9 | pending = undefined; 10 | resolve(fn()); 11 | }); 12 | }); 13 | } 14 | 15 | return pending; 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/detectOverflow.d.ts: -------------------------------------------------------------------------------- 1 | import type { State, SideObject, Padding, PositioningStrategy } from "../types"; 2 | import type { Placement, Boundary, RootBoundary, Context } from "../enums"; 3 | export declare type Options = { 4 | placement: Placement; 5 | strategy: PositioningStrategy; 6 | boundary: Boundary; 7 | rootBoundary: RootBoundary; 8 | elementContext: Context; 9 | altBoundary: boolean; 10 | padding: Padding; 11 | }; 12 | export default function detectOverflow(state: State, options?: Partial): SideObject; 13 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/expandToHashMap.d.ts: -------------------------------------------------------------------------------- 1 | export default function expandToHashMap(value: T, keys: Array): { 2 | [key: string]: T; 3 | }; 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/expandToHashMap.js: -------------------------------------------------------------------------------- 1 | export default function expandToHashMap(value, keys) { 2 | return keys.reduce(function (hashMap, key) { 3 | hashMap[key] = value; 4 | return hashMap; 5 | }, {}); 6 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/expandToHashMap.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function expandToHashMap< 4 | T: number | string | boolean, 5 | K: string 6 | >(value: T, keys: Array): { [key: string]: T } { 7 | return keys.reduce((hashMap, key) => { 8 | hashMap[key] = value; 9 | return hashMap; 10 | }, {}); 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltAxis.d.ts: -------------------------------------------------------------------------------- 1 | export default function getAltAxis(axis: "x" | "y"): "x" | "y"; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltAxis.js: -------------------------------------------------------------------------------- 1 | export default function getAltAxis(axis) { 2 | return axis === 'x' ? 'y' : 'x'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltAxis.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function getAltAxis(axis: 'x' | 'y'): 'x' | 'y' { 4 | return axis === 'x' ? 'y' : 'x'; 5 | } 6 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltLen.d.ts: -------------------------------------------------------------------------------- 1 | export default function getAltLen(len: "width" | "height"): "width" | "height"; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltLen.js: -------------------------------------------------------------------------------- 1 | export default function getAltLen(len) { 2 | return len === 'width' ? 'height' : 'width'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getAltLen.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function getAltLen(len: 'width' | 'height'): 'width' | 'height' { 4 | return len === 'width' ? 'height' : 'width'; 5 | } 6 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getBasePlacement.d.ts: -------------------------------------------------------------------------------- 1 | import { BasePlacement, Placement, auto } from "../enums"; 2 | export default function getBasePlacement(placement: Placement | typeof auto): BasePlacement; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getBasePlacement.js: -------------------------------------------------------------------------------- 1 | import { auto } from "../enums.js"; 2 | export default function getBasePlacement(placement) { 3 | return placement.split('-')[0]; 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getBasePlacement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { type BasePlacement, type Placement, auto } from '../enums'; 3 | 4 | export default function getBasePlacement( 5 | placement: Placement | typeof auto 6 | ): BasePlacement { 7 | return (placement.split('-')[0]: any); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getFreshSideObject.d.ts: -------------------------------------------------------------------------------- 1 | import type { SideObject } from "../types"; 2 | export default function getFreshSideObject(): SideObject; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getFreshSideObject.js: -------------------------------------------------------------------------------- 1 | export default function getFreshSideObject() { 2 | return { 3 | top: 0, 4 | right: 0, 5 | bottom: 0, 6 | left: 0 7 | }; 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getFreshSideObject.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { SideObject } from '../types'; 3 | 4 | export default function getFreshSideObject(): SideObject { 5 | return { 6 | top: 0, 7 | right: 0, 8 | bottom: 0, 9 | left: 0, 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement } from "../enums"; 2 | export default function getMainAxisFromPlacement(placement: Placement): "x" | "y"; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js: -------------------------------------------------------------------------------- 1 | export default function getMainAxisFromPlacement(placement) { 2 | return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Placement } from '../enums'; 3 | 4 | export default function getMainAxisFromPlacement( 5 | placement: Placement 6 | ): 'x' | 'y' { 7 | return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositePlacement.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement } from "../enums"; 2 | export default function getOppositePlacement(placement: Placement): Placement; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositePlacement.js: -------------------------------------------------------------------------------- 1 | var hash = { 2 | left: 'right', 3 | right: 'left', 4 | bottom: 'top', 5 | top: 'bottom' 6 | }; 7 | export default function getOppositePlacement(placement) { 8 | return placement.replace(/left|right|bottom|top/g, function (matched) { 9 | return hash[matched]; 10 | }); 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositePlacement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Placement } from '../enums'; 3 | 4 | const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; 5 | 6 | export default function getOppositePlacement(placement: Placement): Placement { 7 | return (placement.replace( 8 | /left|right|bottom|top/g, 9 | matched => hash[matched] 10 | ): any); 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.d.ts: -------------------------------------------------------------------------------- 1 | import type { Placement } from "../enums"; 2 | export default function getOppositeVariationPlacement(placement: Placement): Placement; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js: -------------------------------------------------------------------------------- 1 | var hash = { 2 | start: 'end', 3 | end: 'start' 4 | }; 5 | export default function getOppositeVariationPlacement(placement) { 6 | return placement.replace(/start|end/g, function (matched) { 7 | return hash[matched]; 8 | }); 9 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Placement } from '../enums'; 3 | 4 | const hash = { start: 'end', end: 'start' }; 5 | 6 | export default function getOppositeVariationPlacement( 7 | placement: Placement 8 | ): Placement { 9 | return (placement.replace(/start|end/g, matched => hash[matched]): any); 10 | } 11 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getVariation.d.ts: -------------------------------------------------------------------------------- 1 | import { Variation, Placement } from "../enums"; 2 | export default function getVariation(placement: Placement): Variation | null | undefined; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getVariation.js: -------------------------------------------------------------------------------- 1 | export default function getVariation(placement) { 2 | return placement.split('-')[1]; 3 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/getVariation.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { type Variation, type Placement } from '../enums'; 3 | 4 | export default function getVariation(placement: Placement): ?Variation { 5 | return (placement.split('-')[1]: any); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/math.d.ts: -------------------------------------------------------------------------------- 1 | export declare const max: (...values: number[]) => number; 2 | export declare const min: (...values: number[]) => number; 3 | export declare const round: (x: number) => number; 4 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/math.js: -------------------------------------------------------------------------------- 1 | export var max = Math.max; 2 | export var min = Math.min; 3 | export var round = Math.round; -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/math.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | export const max = Math.max; 3 | export const min = Math.min; 4 | export const round = Math.round; 5 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergeByName.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export default function mergeByName(modifiers: Array>>): Array>>; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergeByName.js: -------------------------------------------------------------------------------- 1 | export default function mergeByName(modifiers) { 2 | var merged = modifiers.reduce(function (merged, current) { 3 | var existing = merged[current.name]; 4 | merged[current.name] = existing ? Object.assign({}, existing, current, { 5 | options: Object.assign({}, existing.options, current.options), 6 | data: Object.assign({}, existing.data, current.data) 7 | }) : current; 8 | return merged; 9 | }, {}); // IE11 does not support Object.values 10 | 11 | return Object.keys(merged).map(function (key) { 12 | return merged[key]; 13 | }); 14 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergeByName.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Modifier } from '../types'; 3 | 4 | export default function mergeByName( 5 | modifiers: Array<$Shape>> 6 | ): Array<$Shape>> { 7 | const merged = modifiers.reduce((merged, current) => { 8 | const existing = merged[current.name]; 9 | merged[current.name] = existing 10 | ? { 11 | ...existing, 12 | ...current, 13 | options: { ...existing.options, ...current.options }, 14 | data: { ...existing.data, ...current.data }, 15 | } 16 | : current; 17 | return merged; 18 | }, {}); 19 | 20 | // IE11 does not support Object.values 21 | return Object.keys(merged).map(key => merged[key]); 22 | } 23 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergePaddingObject.d.ts: -------------------------------------------------------------------------------- 1 | import type { SideObject } from "../types"; 2 | export default function mergePaddingObject(paddingObject: Partial): SideObject; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergePaddingObject.js: -------------------------------------------------------------------------------- 1 | import getFreshSideObject from "./getFreshSideObject.js"; 2 | export default function mergePaddingObject(paddingObject) { 3 | return Object.assign({}, getFreshSideObject(), paddingObject); 4 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/mergePaddingObject.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { SideObject } from '../types'; 3 | import getFreshSideObject from './getFreshSideObject'; 4 | 5 | export default function mergePaddingObject( 6 | paddingObject: $Shape 7 | ): SideObject { 8 | return { 9 | ...getFreshSideObject(), 10 | ...paddingObject, 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/orderModifiers.d.ts: -------------------------------------------------------------------------------- 1 | import type { Modifier } from "../types"; 2 | export default function orderModifiers(modifiers: Array>): Array>; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/orderModifiers.js: -------------------------------------------------------------------------------- 1 | import { modifierPhases } from "../enums.js"; // source: https://stackoverflow.com/questions/49875255 2 | 3 | function order(modifiers) { 4 | var map = new Map(); 5 | var visited = new Set(); 6 | var result = []; 7 | modifiers.forEach(function (modifier) { 8 | map.set(modifier.name, modifier); 9 | }); // On visiting object, check for its dependencies and visit them recursively 10 | 11 | function sort(modifier) { 12 | visited.add(modifier.name); 13 | var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 14 | requires.forEach(function (dep) { 15 | if (!visited.has(dep)) { 16 | var depModifier = map.get(dep); 17 | 18 | if (depModifier) { 19 | sort(depModifier); 20 | } 21 | } 22 | }); 23 | result.push(modifier); 24 | } 25 | 26 | modifiers.forEach(function (modifier) { 27 | if (!visited.has(modifier.name)) { 28 | // check for visited object 29 | sort(modifier); 30 | } 31 | }); 32 | return result; 33 | } 34 | 35 | export default function orderModifiers(modifiers) { 36 | // order based on dependencies 37 | var orderedModifiers = order(modifiers); // order based on phase 38 | 39 | return modifierPhases.reduce(function (acc, phase) { 40 | return acc.concat(orderedModifiers.filter(function (modifier) { 41 | return modifier.phase === phase; 42 | })); 43 | }, []); 44 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/orderModifiers.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Modifier } from '../types'; 3 | import { modifierPhases } from '../enums'; 4 | 5 | // source: https://stackoverflow.com/questions/49875255 6 | function order(modifiers) { 7 | const map = new Map(); 8 | const visited = new Set(); 9 | const result = []; 10 | 11 | modifiers.forEach(modifier => { 12 | map.set(modifier.name, modifier); 13 | }); 14 | 15 | // On visiting object, check for its dependencies and visit them recursively 16 | function sort(modifier: Modifier) { 17 | visited.add(modifier.name); 18 | 19 | const requires = [ 20 | ...(modifier.requires || []), 21 | ...(modifier.requiresIfExists || []), 22 | ]; 23 | 24 | requires.forEach(dep => { 25 | if (!visited.has(dep)) { 26 | const depModifier = map.get(dep); 27 | 28 | if (depModifier) { 29 | sort(depModifier); 30 | } 31 | } 32 | }); 33 | 34 | result.push(modifier); 35 | } 36 | 37 | modifiers.forEach(modifier => { 38 | if (!visited.has(modifier.name)) { 39 | // check for visited object 40 | sort(modifier); 41 | } 42 | }); 43 | 44 | return result; 45 | } 46 | 47 | export default function orderModifiers( 48 | modifiers: Array> 49 | ): Array> { 50 | // order based on dependencies 51 | const orderedModifiers = order(modifiers); 52 | 53 | // order based on phase 54 | return modifierPhases.reduce((acc, phase) => { 55 | return acc.concat( 56 | orderedModifiers.filter(modifier => modifier.phase === phase) 57 | ); 58 | }, []); 59 | } 60 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/rectToClientRect.d.ts: -------------------------------------------------------------------------------- 1 | import type { Rect, ClientRectObject } from "../types"; 2 | export default function rectToClientRect(rect: Rect): ClientRectObject; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/rectToClientRect.js: -------------------------------------------------------------------------------- 1 | export default function rectToClientRect(rect) { 2 | return Object.assign({}, rect, { 3 | left: rect.x, 4 | top: rect.y, 5 | right: rect.x + rect.width, 6 | bottom: rect.y + rect.height 7 | }); 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/rectToClientRect.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import type { Rect, ClientRectObject } from '../types'; 3 | 4 | export default function rectToClientRect(rect: Rect): ClientRectObject { 5 | return { 6 | ...rect, 7 | left: rect.x, 8 | top: rect.y, 9 | right: rect.x + rect.width, 10 | bottom: rect.y + rect.height, 11 | }; 12 | } 13 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/uniqueBy.d.ts: -------------------------------------------------------------------------------- 1 | export default function uniqueBy(arr: Array, fn: (arg0: T) => any): Array; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/uniqueBy.js: -------------------------------------------------------------------------------- 1 | export default function uniqueBy(arr, fn) { 2 | var identifiers = new Set(); 3 | return arr.filter(function (item) { 4 | var identifier = fn(item); 5 | 6 | if (!identifiers.has(identifier)) { 7 | identifiers.add(identifier); 8 | return true; 9 | } 10 | }); 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/uniqueBy.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export default function uniqueBy(arr: Array, fn: T => any): Array { 4 | const identifiers = new Set(); 5 | 6 | return arr.filter(item => { 7 | const identifier = fn(item); 8 | 9 | if (!identifiers.has(identifier)) { 10 | identifiers.add(identifier); 11 | return true; 12 | } 13 | }); 14 | } 15 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/userAgent.d.ts: -------------------------------------------------------------------------------- 1 | export default function getUAString(): string; 2 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/userAgent.js: -------------------------------------------------------------------------------- 1 | export default function getUAString() { 2 | var uaData = navigator.userAgentData; 3 | 4 | if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) { 5 | return uaData.brands.map(function (item) { 6 | return item.brand + "/" + item.version; 7 | }).join(' '); 8 | } 9 | 10 | return navigator.userAgent; 11 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/userAgent.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | type Navigator = Navigator & { userAgentData?: NavigatorUAData }; 3 | 4 | interface NavigatorUAData { 5 | brands: Array<{ brand: string, version: string }>; 6 | mobile: boolean; 7 | platform: string; 8 | } 9 | 10 | export default function getUAString(): string { 11 | const uaData = (navigator: Navigator).userAgentData; 12 | 13 | if (uaData?.brands && Array.isArray(uaData.brands)) { 14 | return uaData.brands 15 | .map((item) => `${item.brand}/${item.version}`) 16 | .join(' '); 17 | } 18 | 19 | return navigator.userAgent; 20 | } 21 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/within.d.ts: -------------------------------------------------------------------------------- 1 | export declare function within(min: number, value: number, max: number): number; 2 | export declare function withinMaxClamp(min: number, value: number, max: number): number; 3 | -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/within.js: -------------------------------------------------------------------------------- 1 | import { max as mathMax, min as mathMin } from "./math.js"; 2 | export function within(min, value, max) { 3 | return mathMax(min, mathMin(value, max)); 4 | } 5 | export function withinMaxClamp(min, value, max) { 6 | var v = within(min, value, max); 7 | return v > max ? max : v; 8 | } -------------------------------------------------------------------------------- /node_modules/@popperjs/core/lib/utils/within.js.flow: -------------------------------------------------------------------------------- 1 | // @flow 2 | import { max as mathMax, min as mathMin } from './math'; 3 | 4 | export function within(min: number, value: number, max: number): number { 5 | return mathMax(min, mathMin(value, max)); 6 | } 7 | 8 | export function withinMaxClamp(min: number, value: number, max: number) { 9 | const v = within(min, value, max); 10 | return v > max ? max : v; 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/bootstrap/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2011-2023 The Bootstrap Authors 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/dist/util/component-functions.js: -------------------------------------------------------------------------------- 1 | /*! 2 | * Bootstrap component-functions.js v5.3.2 (https://getbootstrap.com/) 3 | * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | */ 6 | (function (global, factory) { 7 | typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('../dom/event-handler.js'), require('../dom/selector-engine.js'), require('./index.js')) : 8 | typeof define === 'function' && define.amd ? define(['exports', '../dom/event-handler', '../dom/selector-engine', './index'], factory) : 9 | (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComponentFunctions = {}, global.EventHandler, global.SelectorEngine, global.Index)); 10 | })(this, (function (exports, EventHandler, SelectorEngine, index_js) { 'use strict'; 11 | 12 | /** 13 | * -------------------------------------------------------------------------- 14 | * Bootstrap util/component-functions.js 15 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 16 | * -------------------------------------------------------------------------- 17 | */ 18 | 19 | const enableDismissTrigger = (component, method = 'hide') => { 20 | const clickEvent = `click.dismiss${component.EVENT_KEY}`; 21 | const name = component.NAME; 22 | EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 23 | if (['A', 'AREA'].includes(this.tagName)) { 24 | event.preventDefault(); 25 | } 26 | if (index_js.isDisabled(this)) { 27 | return; 28 | } 29 | const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`); 30 | const instance = component.getOrCreateInstance(target); 31 | 32 | // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 33 | instance[method](); 34 | }); 35 | }; 36 | 37 | exports.enableDismissTrigger = enableDismissTrigger; 38 | 39 | Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 40 | 41 | })); 42 | //# sourceMappingURL=component-functions.js.map 43 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/index.esm.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap index.esm.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | export { default as Alert } from './src/alert.js' 9 | export { default as Button } from './src/button.js' 10 | export { default as Carousel } from './src/carousel.js' 11 | export { default as Collapse } from './src/collapse.js' 12 | export { default as Dropdown } from './src/dropdown.js' 13 | export { default as Modal } from './src/modal.js' 14 | export { default as Offcanvas } from './src/offcanvas.js' 15 | export { default as Popover } from './src/popover.js' 16 | export { default as ScrollSpy } from './src/scrollspy.js' 17 | export { default as Tab } from './src/tab.js' 18 | export { default as Toast } from './src/toast.js' 19 | export { default as Tooltip } from './src/tooltip.js' 20 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/index.umd.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap index.umd.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import Alert from './src/alert.js' 9 | import Button from './src/button.js' 10 | import Carousel from './src/carousel.js' 11 | import Collapse from './src/collapse.js' 12 | import Dropdown from './src/dropdown.js' 13 | import Modal from './src/modal.js' 14 | import Offcanvas from './src/offcanvas.js' 15 | import Popover from './src/popover.js' 16 | import ScrollSpy from './src/scrollspy.js' 17 | import Tab from './src/tab.js' 18 | import Toast from './src/toast.js' 19 | import Tooltip from './src/tooltip.js' 20 | 21 | export default { 22 | Alert, 23 | Button, 24 | Carousel, 25 | Collapse, 26 | Dropdown, 27 | Modal, 28 | Offcanvas, 29 | Popover, 30 | ScrollSpy, 31 | Tab, 32 | Toast, 33 | Tooltip 34 | } 35 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/alert.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap alert.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import BaseComponent from './base-component.js' 9 | import EventHandler from './dom/event-handler.js' 10 | import { enableDismissTrigger } from './util/component-functions.js' 11 | import { defineJQueryPlugin } from './util/index.js' 12 | 13 | /** 14 | * Constants 15 | */ 16 | 17 | const NAME = 'alert' 18 | const DATA_KEY = 'bs.alert' 19 | const EVENT_KEY = `.${DATA_KEY}` 20 | 21 | const EVENT_CLOSE = `close${EVENT_KEY}` 22 | const EVENT_CLOSED = `closed${EVENT_KEY}` 23 | const CLASS_NAME_FADE = 'fade' 24 | const CLASS_NAME_SHOW = 'show' 25 | 26 | /** 27 | * Class definition 28 | */ 29 | 30 | class Alert extends BaseComponent { 31 | // Getters 32 | static get NAME() { 33 | return NAME 34 | } 35 | 36 | // Public 37 | close() { 38 | const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE) 39 | 40 | if (closeEvent.defaultPrevented) { 41 | return 42 | } 43 | 44 | this._element.classList.remove(CLASS_NAME_SHOW) 45 | 46 | const isAnimated = this._element.classList.contains(CLASS_NAME_FADE) 47 | this._queueCallback(() => this._destroyElement(), this._element, isAnimated) 48 | } 49 | 50 | // Private 51 | _destroyElement() { 52 | this._element.remove() 53 | EventHandler.trigger(this._element, EVENT_CLOSED) 54 | this.dispose() 55 | } 56 | 57 | // Static 58 | static jQueryInterface(config) { 59 | return this.each(function () { 60 | const data = Alert.getOrCreateInstance(this) 61 | 62 | if (typeof config !== 'string') { 63 | return 64 | } 65 | 66 | if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 67 | throw new TypeError(`No method named "${config}"`) 68 | } 69 | 70 | data[config](this) 71 | }) 72 | } 73 | } 74 | 75 | /** 76 | * Data API implementation 77 | */ 78 | 79 | enableDismissTrigger(Alert, 'close') 80 | 81 | /** 82 | * jQuery 83 | */ 84 | 85 | defineJQueryPlugin(Alert) 86 | 87 | export default Alert 88 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/button.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap button.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import BaseComponent from './base-component.js' 9 | import EventHandler from './dom/event-handler.js' 10 | import { defineJQueryPlugin } from './util/index.js' 11 | 12 | /** 13 | * Constants 14 | */ 15 | 16 | const NAME = 'button' 17 | const DATA_KEY = 'bs.button' 18 | const EVENT_KEY = `.${DATA_KEY}` 19 | const DATA_API_KEY = '.data-api' 20 | 21 | const CLASS_NAME_ACTIVE = 'active' 22 | const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]' 23 | const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}` 24 | 25 | /** 26 | * Class definition 27 | */ 28 | 29 | class Button extends BaseComponent { 30 | // Getters 31 | static get NAME() { 32 | return NAME 33 | } 34 | 35 | // Public 36 | toggle() { 37 | // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method 38 | this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE)) 39 | } 40 | 41 | // Static 42 | static jQueryInterface(config) { 43 | return this.each(function () { 44 | const data = Button.getOrCreateInstance(this) 45 | 46 | if (config === 'toggle') { 47 | data[config]() 48 | } 49 | }) 50 | } 51 | } 52 | 53 | /** 54 | * Data API implementation 55 | */ 56 | 57 | EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, event => { 58 | event.preventDefault() 59 | 60 | const button = event.target.closest(SELECTOR_DATA_TOGGLE) 61 | const data = Button.getOrCreateInstance(button) 62 | 63 | data.toggle() 64 | }) 65 | 66 | /** 67 | * jQuery 68 | */ 69 | 70 | defineJQueryPlugin(Button) 71 | 72 | export default Button 73 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/dom/data.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap dom/data.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | /** 9 | * Constants 10 | */ 11 | 12 | const elementMap = new Map() 13 | 14 | export default { 15 | set(element, key, instance) { 16 | if (!elementMap.has(element)) { 17 | elementMap.set(element, new Map()) 18 | } 19 | 20 | const instanceMap = elementMap.get(element) 21 | 22 | // make it clear we only want one instance per element 23 | // can be removed later when multiple key/instances are fine to be used 24 | if (!instanceMap.has(key) && instanceMap.size !== 0) { 25 | // eslint-disable-next-line no-console 26 | console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`) 27 | return 28 | } 29 | 30 | instanceMap.set(key, instance) 31 | }, 32 | 33 | get(element, key) { 34 | if (elementMap.has(element)) { 35 | return elementMap.get(element).get(key) || null 36 | } 37 | 38 | return null 39 | }, 40 | 41 | remove(element, key) { 42 | if (!elementMap.has(element)) { 43 | return 44 | } 45 | 46 | const instanceMap = elementMap.get(element) 47 | 48 | instanceMap.delete(key) 49 | 50 | // free up element references if there are no instances left for an element 51 | if (instanceMap.size === 0) { 52 | elementMap.delete(element) 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/dom/manipulator.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap dom/manipulator.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | function normalizeData(value) { 9 | if (value === 'true') { 10 | return true 11 | } 12 | 13 | if (value === 'false') { 14 | return false 15 | } 16 | 17 | if (value === Number(value).toString()) { 18 | return Number(value) 19 | } 20 | 21 | if (value === '' || value === 'null') { 22 | return null 23 | } 24 | 25 | if (typeof value !== 'string') { 26 | return value 27 | } 28 | 29 | try { 30 | return JSON.parse(decodeURIComponent(value)) 31 | } catch { 32 | return value 33 | } 34 | } 35 | 36 | function normalizeDataKey(key) { 37 | return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`) 38 | } 39 | 40 | const Manipulator = { 41 | setDataAttribute(element, key, value) { 42 | element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value) 43 | }, 44 | 45 | removeDataAttribute(element, key) { 46 | element.removeAttribute(`data-bs-${normalizeDataKey(key)}`) 47 | }, 48 | 49 | getDataAttributes(element) { 50 | if (!element) { 51 | return {} 52 | } 53 | 54 | const attributes = {} 55 | const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig')) 56 | 57 | for (const key of bsKeys) { 58 | let pureKey = key.replace(/^bs/, '') 59 | pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length) 60 | attributes[pureKey] = normalizeData(element.dataset[key]) 61 | } 62 | 63 | return attributes 64 | }, 65 | 66 | getDataAttribute(element, key) { 67 | return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`)) 68 | } 69 | } 70 | 71 | export default Manipulator 72 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/popover.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap popover.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import Tooltip from './tooltip.js' 9 | import { defineJQueryPlugin } from './util/index.js' 10 | 11 | /** 12 | * Constants 13 | */ 14 | 15 | const NAME = 'popover' 16 | 17 | const SELECTOR_TITLE = '.popover-header' 18 | const SELECTOR_CONTENT = '.popover-body' 19 | 20 | const Default = { 21 | ...Tooltip.Default, 22 | content: '', 23 | offset: [0, 8], 24 | placement: 'right', 25 | template: '', 30 | trigger: 'click' 31 | } 32 | 33 | const DefaultType = { 34 | ...Tooltip.DefaultType, 35 | content: '(null|string|element|function)' 36 | } 37 | 38 | /** 39 | * Class definition 40 | */ 41 | 42 | class Popover extends Tooltip { 43 | // Getters 44 | static get Default() { 45 | return Default 46 | } 47 | 48 | static get DefaultType() { 49 | return DefaultType 50 | } 51 | 52 | static get NAME() { 53 | return NAME 54 | } 55 | 56 | // Overrides 57 | _isWithContent() { 58 | return this._getTitle() || this._getContent() 59 | } 60 | 61 | // Private 62 | _getContentForTemplate() { 63 | return { 64 | [SELECTOR_TITLE]: this._getTitle(), 65 | [SELECTOR_CONTENT]: this._getContent() 66 | } 67 | } 68 | 69 | _getContent() { 70 | return this._resolvePossibleFunction(this._config.content) 71 | } 72 | 73 | // Static 74 | static jQueryInterface(config) { 75 | return this.each(function () { 76 | const data = Popover.getOrCreateInstance(this, config) 77 | 78 | if (typeof config !== 'string') { 79 | return 80 | } 81 | 82 | if (typeof data[config] === 'undefined') { 83 | throw new TypeError(`No method named "${config}"`) 84 | } 85 | 86 | data[config]() 87 | }) 88 | } 89 | } 90 | 91 | /** 92 | * jQuery 93 | */ 94 | 95 | defineJQueryPlugin(Popover) 96 | 97 | export default Popover 98 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/util/component-functions.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap util/component-functions.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import EventHandler from '../dom/event-handler.js' 9 | import SelectorEngine from '../dom/selector-engine.js' 10 | import { isDisabled } from './index.js' 11 | 12 | const enableDismissTrigger = (component, method = 'hide') => { 13 | const clickEvent = `click.dismiss${component.EVENT_KEY}` 14 | const name = component.NAME 15 | 16 | EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 17 | if (['A', 'AREA'].includes(this.tagName)) { 18 | event.preventDefault() 19 | } 20 | 21 | if (isDisabled(this)) { 22 | return 23 | } 24 | 25 | const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`) 26 | const instance = component.getOrCreateInstance(target) 27 | 28 | // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 29 | instance[method]() 30 | }) 31 | } 32 | 33 | export { 34 | enableDismissTrigger 35 | } 36 | -------------------------------------------------------------------------------- /node_modules/bootstrap/js/src/util/config.js: -------------------------------------------------------------------------------- 1 | /** 2 | * -------------------------------------------------------------------------- 3 | * Bootstrap util/config.js 4 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5 | * -------------------------------------------------------------------------- 6 | */ 7 | 8 | import Manipulator from '../dom/manipulator.js' 9 | import { isElement, toType } from './index.js' 10 | 11 | /** 12 | * Class definition 13 | */ 14 | 15 | class Config { 16 | // Getters 17 | static get Default() { 18 | return {} 19 | } 20 | 21 | static get DefaultType() { 22 | return {} 23 | } 24 | 25 | static get NAME() { 26 | throw new Error('You have to implement the static method "NAME", for each component!') 27 | } 28 | 29 | _getConfig(config) { 30 | config = this._mergeConfigObj(config) 31 | config = this._configAfterMerge(config) 32 | this._typeCheckConfig(config) 33 | return config 34 | } 35 | 36 | _configAfterMerge(config) { 37 | return config 38 | } 39 | 40 | _mergeConfigObj(config, element) { 41 | const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {} // try to parse 42 | 43 | return { 44 | ...this.constructor.Default, 45 | ...(typeof jsonConfig === 'object' ? jsonConfig : {}), 46 | ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}), 47 | ...(typeof config === 'object' ? config : {}) 48 | } 49 | } 50 | 51 | _typeCheckConfig(config, configTypes = this.constructor.DefaultType) { 52 | for (const [property, expectedTypes] of Object.entries(configTypes)) { 53 | const value = config[property] 54 | const valueType = isElement(value) ? 'element' : toType(value) 55 | 56 | if (!new RegExp(expectedTypes).test(valueType)) { 57 | throw new TypeError( 58 | `${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".` 59 | ) 60 | } 61 | } 62 | } 63 | } 64 | 65 | export default Config 66 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_badge.scss: -------------------------------------------------------------------------------- 1 | // Base class 2 | // 3 | // Requires one of the contextual, color modifier classes for `color` and 4 | // `background-color`. 5 | 6 | .badge { 7 | // scss-docs-start badge-css-vars 8 | --#{$prefix}badge-padding-x: #{$badge-padding-x}; 9 | --#{$prefix}badge-padding-y: #{$badge-padding-y}; 10 | @include rfs($badge-font-size, --#{$prefix}badge-font-size); 11 | --#{$prefix}badge-font-weight: #{$badge-font-weight}; 12 | --#{$prefix}badge-color: #{$badge-color}; 13 | --#{$prefix}badge-border-radius: #{$badge-border-radius}; 14 | // scss-docs-end badge-css-vars 15 | 16 | display: inline-block; 17 | padding: var(--#{$prefix}badge-padding-y) var(--#{$prefix}badge-padding-x); 18 | @include font-size(var(--#{$prefix}badge-font-size)); 19 | font-weight: var(--#{$prefix}badge-font-weight); 20 | line-height: 1; 21 | color: var(--#{$prefix}badge-color); 22 | text-align: center; 23 | white-space: nowrap; 24 | vertical-align: baseline; 25 | @include border-radius(var(--#{$prefix}badge-border-radius)); 26 | @include gradient-bg(); 27 | 28 | // Empty badges collapse automatically 29 | &:empty { 30 | display: none; 31 | } 32 | } 33 | 34 | // Quick fix for badges in buttons 35 | .btn .badge { 36 | position: relative; 37 | top: -1px; 38 | } 39 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_breadcrumb.scss: -------------------------------------------------------------------------------- 1 | .breadcrumb { 2 | // scss-docs-start breadcrumb-css-vars 3 | --#{$prefix}breadcrumb-padding-x: #{$breadcrumb-padding-x}; 4 | --#{$prefix}breadcrumb-padding-y: #{$breadcrumb-padding-y}; 5 | --#{$prefix}breadcrumb-margin-bottom: #{$breadcrumb-margin-bottom}; 6 | @include rfs($breadcrumb-font-size, --#{$prefix}breadcrumb-font-size); 7 | --#{$prefix}breadcrumb-bg: #{$breadcrumb-bg}; 8 | --#{$prefix}breadcrumb-border-radius: #{$breadcrumb-border-radius}; 9 | --#{$prefix}breadcrumb-divider-color: #{$breadcrumb-divider-color}; 10 | --#{$prefix}breadcrumb-item-padding-x: #{$breadcrumb-item-padding-x}; 11 | --#{$prefix}breadcrumb-item-active-color: #{$breadcrumb-active-color}; 12 | // scss-docs-end breadcrumb-css-vars 13 | 14 | display: flex; 15 | flex-wrap: wrap; 16 | padding: var(--#{$prefix}breadcrumb-padding-y) var(--#{$prefix}breadcrumb-padding-x); 17 | margin-bottom: var(--#{$prefix}breadcrumb-margin-bottom); 18 | @include font-size(var(--#{$prefix}breadcrumb-font-size)); 19 | list-style: none; 20 | background-color: var(--#{$prefix}breadcrumb-bg); 21 | @include border-radius(var(--#{$prefix}breadcrumb-border-radius)); 22 | } 23 | 24 | .breadcrumb-item { 25 | // The separator between breadcrumbs (by default, a forward-slash: "/") 26 | + .breadcrumb-item { 27 | padding-left: var(--#{$prefix}breadcrumb-item-padding-x); 28 | 29 | &::before { 30 | float: left; // Suppress inline spacings and underlining of the separator 31 | padding-right: var(--#{$prefix}breadcrumb-item-padding-x); 32 | color: var(--#{$prefix}breadcrumb-divider-color); 33 | content: var(--#{$prefix}breadcrumb-divider, escape-svg($breadcrumb-divider)) #{"/* rtl:"} var(--#{$prefix}breadcrumb-divider, escape-svg($breadcrumb-divider-flipped)) #{"*/"}; 34 | } 35 | } 36 | 37 | &.active { 38 | color: var(--#{$prefix}breadcrumb-item-active-color); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_close.scss: -------------------------------------------------------------------------------- 1 | // Transparent background and border properties included for button version. 2 | // iOS requires the button element instead of an anchor tag. 3 | // If you want the anchor version, it requires `href="#"`. 4 | // See https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile 5 | 6 | .btn-close { 7 | // scss-docs-start close-css-vars 8 | --#{$prefix}btn-close-color: #{$btn-close-color}; 9 | --#{$prefix}btn-close-bg: #{ escape-svg($btn-close-bg) }; 10 | --#{$prefix}btn-close-opacity: #{$btn-close-opacity}; 11 | --#{$prefix}btn-close-hover-opacity: #{$btn-close-hover-opacity}; 12 | --#{$prefix}btn-close-focus-shadow: #{$btn-close-focus-shadow}; 13 | --#{$prefix}btn-close-focus-opacity: #{$btn-close-focus-opacity}; 14 | --#{$prefix}btn-close-disabled-opacity: #{$btn-close-disabled-opacity}; 15 | --#{$prefix}btn-close-white-filter: #{$btn-close-white-filter}; 16 | // scss-docs-end close-css-vars 17 | 18 | box-sizing: content-box; 19 | width: $btn-close-width; 20 | height: $btn-close-height; 21 | padding: $btn-close-padding-y $btn-close-padding-x; 22 | color: var(--#{$prefix}btn-close-color); 23 | background: transparent var(--#{$prefix}btn-close-bg) center / $btn-close-width auto no-repeat; // include transparent for button elements 24 | border: 0; // for button elements 25 | @include border-radius(); 26 | opacity: var(--#{$prefix}btn-close-opacity); 27 | 28 | // Override 's hover style 29 | &:hover { 30 | color: var(--#{$prefix}btn-close-color); 31 | text-decoration: none; 32 | opacity: var(--#{$prefix}btn-close-hover-opacity); 33 | } 34 | 35 | &:focus { 36 | outline: 0; 37 | box-shadow: var(--#{$prefix}btn-close-focus-shadow); 38 | opacity: var(--#{$prefix}btn-close-focus-opacity); 39 | } 40 | 41 | &:disabled, 42 | &.disabled { 43 | pointer-events: none; 44 | user-select: none; 45 | opacity: var(--#{$prefix}btn-close-disabled-opacity); 46 | } 47 | } 48 | 49 | @mixin btn-close-white() { 50 | filter: var(--#{$prefix}btn-close-white-filter); 51 | } 52 | 53 | .btn-close-white { 54 | @include btn-close-white(); 55 | } 56 | 57 | @if $enable-dark-mode { 58 | @include color-mode(dark) { 59 | .btn-close { 60 | @include btn-close-white(); 61 | } 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_containers.scss: -------------------------------------------------------------------------------- 1 | // Container widths 2 | // 3 | // Set the container width, and override it for fixed navbars in media queries. 4 | 5 | @if $enable-container-classes { 6 | // Single container class with breakpoint max-widths 7 | .container, 8 | // 100% wide container at all breakpoints 9 | .container-fluid { 10 | @include make-container(); 11 | } 12 | 13 | // Responsive containers that are 100% wide until a breakpoint 14 | @each $breakpoint, $container-max-width in $container-max-widths { 15 | .container-#{$breakpoint} { 16 | @extend .container-fluid; 17 | } 18 | 19 | @include media-breakpoint-up($breakpoint, $grid-breakpoints) { 20 | %responsive-container-#{$breakpoint} { 21 | max-width: $container-max-width; 22 | } 23 | 24 | // Extend each breakpoint which is smaller or equal to the current breakpoint 25 | $extend-breakpoint: true; 26 | 27 | @each $name, $width in $grid-breakpoints { 28 | @if ($extend-breakpoint) { 29 | .container#{breakpoint-infix($name, $grid-breakpoints)} { 30 | @extend %responsive-container-#{$breakpoint}; 31 | } 32 | 33 | // Once the current breakpoint is reached, stop extending 34 | @if ($breakpoint == $name) { 35 | $extend-breakpoint: false; 36 | } 37 | } 38 | } 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_forms.scss: -------------------------------------------------------------------------------- 1 | @import "forms/labels"; 2 | @import "forms/form-text"; 3 | @import "forms/form-control"; 4 | @import "forms/form-select"; 5 | @import "forms/form-check"; 6 | @import "forms/form-range"; 7 | @import "forms/floating-labels"; 8 | @import "forms/input-group"; 9 | @import "forms/validation"; 10 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_grid.scss: -------------------------------------------------------------------------------- 1 | // Row 2 | // 3 | // Rows contain your columns. 4 | 5 | :root { 6 | @each $name, $value in $grid-breakpoints { 7 | --#{$prefix}breakpoint-#{$name}: #{$value}; 8 | } 9 | } 10 | 11 | @if $enable-grid-classes { 12 | .row { 13 | @include make-row(); 14 | 15 | > * { 16 | @include make-col-ready(); 17 | } 18 | } 19 | } 20 | 21 | @if $enable-cssgrid { 22 | .grid { 23 | display: grid; 24 | grid-template-rows: repeat(var(--#{$prefix}rows, 1), 1fr); 25 | grid-template-columns: repeat(var(--#{$prefix}columns, #{$grid-columns}), 1fr); 26 | gap: var(--#{$prefix}gap, #{$grid-gutter-width}); 27 | 28 | @include make-cssgrid(); 29 | } 30 | } 31 | 32 | 33 | // Columns 34 | // 35 | // Common styles for small and large grid columns 36 | 37 | @if $enable-grid-classes { 38 | @include make-grid-columns(); 39 | } 40 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_helpers.scss: -------------------------------------------------------------------------------- 1 | @import "helpers/clearfix"; 2 | @import "helpers/color-bg"; 3 | @import "helpers/colored-links"; 4 | @import "helpers/focus-ring"; 5 | @import "helpers/icon-link"; 6 | @import "helpers/ratio"; 7 | @import "helpers/position"; 8 | @import "helpers/stacks"; 9 | @import "helpers/visually-hidden"; 10 | @import "helpers/stretched-link"; 11 | @import "helpers/text-truncation"; 12 | @import "helpers/vr"; 13 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_images.scss: -------------------------------------------------------------------------------- 1 | // Responsive images (ensure images don't scale beyond their parents) 2 | // 3 | // This is purposefully opt-in via an explicit class rather than being the default for all ``s. 4 | // We previously tried the "images are responsive by default" approach in Bootstrap v2, 5 | // and abandoned it in Bootstrap v3 because it breaks lots of third-party widgets (including Google Maps) 6 | // which weren't expecting the images within themselves to be involuntarily resized. 7 | // See also https://github.com/twbs/bootstrap/issues/18178 8 | .img-fluid { 9 | @include img-fluid(); 10 | } 11 | 12 | 13 | // Image thumbnails 14 | .img-thumbnail { 15 | padding: $thumbnail-padding; 16 | background-color: $thumbnail-bg; 17 | border: $thumbnail-border-width solid $thumbnail-border-color; 18 | @include border-radius($thumbnail-border-radius); 19 | @include box-shadow($thumbnail-box-shadow); 20 | 21 | // Keep them at most 100% wide 22 | @include img-fluid(); 23 | } 24 | 25 | // 26 | // Figures 27 | // 28 | 29 | .figure { 30 | // Ensures the caption's text aligns with the image. 31 | display: inline-block; 32 | } 33 | 34 | .figure-img { 35 | margin-bottom: $spacer * .5; 36 | line-height: 1; 37 | } 38 | 39 | .figure-caption { 40 | @include font-size($figure-caption-font-size); 41 | color: $figure-caption-color; 42 | } 43 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_mixins.scss: -------------------------------------------------------------------------------- 1 | // Toggles 2 | // 3 | // Used in conjunction with global variables to enable certain theme features. 4 | 5 | // Vendor 6 | @import "vendor/rfs"; 7 | 8 | // Deprecate 9 | @import "mixins/deprecate"; 10 | 11 | // Helpers 12 | @import "mixins/breakpoints"; 13 | @import "mixins/color-mode"; 14 | @import "mixins/color-scheme"; 15 | @import "mixins/image"; 16 | @import "mixins/resize"; 17 | @import "mixins/visually-hidden"; 18 | @import "mixins/reset-text"; 19 | @import "mixins/text-truncate"; 20 | 21 | // Utilities 22 | @import "mixins/utilities"; 23 | 24 | // Components 25 | @import "mixins/backdrop"; 26 | @import "mixins/buttons"; 27 | @import "mixins/caret"; 28 | @import "mixins/pagination"; 29 | @import "mixins/lists"; 30 | @import "mixins/forms"; 31 | @import "mixins/table-variants"; 32 | 33 | // Skins 34 | @import "mixins/border-radius"; 35 | @import "mixins/box-shadow"; 36 | @import "mixins/gradients"; 37 | @import "mixins/transition"; 38 | 39 | // Layout 40 | @import "mixins/clearfix"; 41 | @import "mixins/container"; 42 | @import "mixins/grid"; 43 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_placeholders.scss: -------------------------------------------------------------------------------- 1 | .placeholder { 2 | display: inline-block; 3 | min-height: 1em; 4 | vertical-align: middle; 5 | cursor: wait; 6 | background-color: currentcolor; 7 | opacity: $placeholder-opacity-max; 8 | 9 | &.btn::before { 10 | display: inline-block; 11 | content: ""; 12 | } 13 | } 14 | 15 | // Sizing 16 | .placeholder-xs { 17 | min-height: .6em; 18 | } 19 | 20 | .placeholder-sm { 21 | min-height: .8em; 22 | } 23 | 24 | .placeholder-lg { 25 | min-height: 1.2em; 26 | } 27 | 28 | // Animation 29 | .placeholder-glow { 30 | .placeholder { 31 | animation: placeholder-glow 2s ease-in-out infinite; 32 | } 33 | } 34 | 35 | @keyframes placeholder-glow { 36 | 50% { 37 | opacity: $placeholder-opacity-min; 38 | } 39 | } 40 | 41 | .placeholder-wave { 42 | mask-image: linear-gradient(130deg, $black 55%, rgba(0, 0, 0, (1 - $placeholder-opacity-min)) 75%, $black 95%); 43 | mask-size: 200% 100%; 44 | animation: placeholder-wave 2s linear infinite; 45 | } 46 | 47 | @keyframes placeholder-wave { 48 | 100% { 49 | mask-position: -200% 0%; 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_transitions.scss: -------------------------------------------------------------------------------- 1 | .fade { 2 | @include transition($transition-fade); 3 | 4 | &:not(.show) { 5 | opacity: 0; 6 | } 7 | } 8 | 9 | // scss-docs-start collapse-classes 10 | .collapse { 11 | &:not(.show) { 12 | display: none; 13 | } 14 | } 15 | 16 | .collapsing { 17 | height: 0; 18 | overflow: hidden; 19 | @include transition($transition-collapse); 20 | 21 | &.collapse-horizontal { 22 | width: 0; 23 | height: auto; 24 | @include transition($transition-collapse-width); 25 | } 26 | } 27 | // scss-docs-end collapse-classes 28 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/_type.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Headings 3 | // 4 | .h1 { 5 | @extend h1; 6 | } 7 | 8 | .h2 { 9 | @extend h2; 10 | } 11 | 12 | .h3 { 13 | @extend h3; 14 | } 15 | 16 | .h4 { 17 | @extend h4; 18 | } 19 | 20 | .h5 { 21 | @extend h5; 22 | } 23 | 24 | .h6 { 25 | @extend h6; 26 | } 27 | 28 | 29 | .lead { 30 | @include font-size($lead-font-size); 31 | font-weight: $lead-font-weight; 32 | } 33 | 34 | // Type display classes 35 | @each $display, $font-size in $display-font-sizes { 36 | .display-#{$display} { 37 | @include font-size($font-size); 38 | font-family: $display-font-family; 39 | font-style: $display-font-style; 40 | font-weight: $display-font-weight; 41 | line-height: $display-line-height; 42 | } 43 | } 44 | 45 | // 46 | // Emphasis 47 | // 48 | .small { 49 | @extend small; 50 | } 51 | 52 | .mark { 53 | @extend mark; 54 | } 55 | 56 | // 57 | // Lists 58 | // 59 | 60 | .list-unstyled { 61 | @include list-unstyled(); 62 | } 63 | 64 | // Inline turns list items into inline-block 65 | .list-inline { 66 | @include list-unstyled(); 67 | } 68 | .list-inline-item { 69 | display: inline-block; 70 | 71 | &:not(:last-child) { 72 | margin-right: $list-inline-padding; 73 | } 74 | } 75 | 76 | 77 | // 78 | // Misc 79 | // 80 | 81 | // Builds on `abbr` 82 | .initialism { 83 | @include font-size($initialism-font-size); 84 | text-transform: uppercase; 85 | } 86 | 87 | // Blockquotes 88 | .blockquote { 89 | margin-bottom: $blockquote-margin-y; 90 | @include font-size($blockquote-font-size); 91 | 92 | > :last-child { 93 | margin-bottom: 0; 94 | } 95 | } 96 | 97 | .blockquote-footer { 98 | margin-top: -$blockquote-margin-y; 99 | margin-bottom: $blockquote-margin-y; 100 | @include font-size($blockquote-footer-font-size); 101 | color: $blockquote-footer-color; 102 | 103 | &::before { 104 | content: "\2014\00A0"; // em dash, nbsp 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/bootstrap-grid.scss: -------------------------------------------------------------------------------- 1 | @import "mixins/banner"; 2 | @include bsBanner(Grid); 3 | 4 | $include-column-box-sizing: true !default; 5 | 6 | @import "functions"; 7 | @import "variables"; 8 | @import "variables-dark"; 9 | @import "maps"; 10 | 11 | @import "mixins/breakpoints"; 12 | @import "mixins/container"; 13 | @import "mixins/grid"; 14 | @import "mixins/utilities"; 15 | 16 | @import "vendor/rfs"; 17 | 18 | @import "containers"; 19 | @import "grid"; 20 | 21 | @import "utilities"; 22 | // Only use the utilities we need 23 | // stylelint-disable-next-line scss/dollar-variable-default 24 | $utilities: map-get-multiple( 25 | $utilities, 26 | ( 27 | "display", 28 | "order", 29 | "flex", 30 | "flex-direction", 31 | "flex-grow", 32 | "flex-shrink", 33 | "flex-wrap", 34 | "justify-content", 35 | "align-items", 36 | "align-content", 37 | "align-self", 38 | "margin", 39 | "margin-x", 40 | "margin-y", 41 | "margin-top", 42 | "margin-end", 43 | "margin-bottom", 44 | "margin-start", 45 | "negative-margin", 46 | "negative-margin-x", 47 | "negative-margin-y", 48 | "negative-margin-top", 49 | "negative-margin-end", 50 | "negative-margin-bottom", 51 | "negative-margin-start", 52 | "padding", 53 | "padding-x", 54 | "padding-y", 55 | "padding-top", 56 | "padding-end", 57 | "padding-bottom", 58 | "padding-start", 59 | ) 60 | ); 61 | 62 | @import "utilities/api"; 63 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/bootstrap-reboot.scss: -------------------------------------------------------------------------------- 1 | @import "mixins/banner"; 2 | @include bsBanner(Reboot); 3 | 4 | @import "functions"; 5 | @import "variables"; 6 | @import "variables-dark"; 7 | @import "maps"; 8 | @import "mixins"; 9 | @import "root"; 10 | @import "reboot"; 11 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/bootstrap-utilities.scss: -------------------------------------------------------------------------------- 1 | @import "mixins/banner"; 2 | @include bsBanner(Utilities); 3 | 4 | // Configuration 5 | @import "functions"; 6 | @import "variables"; 7 | @import "variables-dark"; 8 | @import "maps"; 9 | @import "mixins"; 10 | @import "utilities"; 11 | 12 | // Layout & components 13 | @import "root"; 14 | 15 | // Helpers 16 | @import "helpers"; 17 | 18 | // Utilities 19 | @import "utilities/api"; 20 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/bootstrap.scss: -------------------------------------------------------------------------------- 1 | @import "mixins/banner"; 2 | @include bsBanner(""); 3 | 4 | 5 | // scss-docs-start import-stack 6 | // Configuration 7 | @import "functions"; 8 | @import "variables"; 9 | @import "variables-dark"; 10 | @import "maps"; 11 | @import "mixins"; 12 | @import "utilities"; 13 | 14 | // Layout & components 15 | @import "root"; 16 | @import "reboot"; 17 | @import "type"; 18 | @import "images"; 19 | @import "containers"; 20 | @import "grid"; 21 | @import "tables"; 22 | @import "forms"; 23 | @import "buttons"; 24 | @import "transitions"; 25 | @import "dropdown"; 26 | @import "button-group"; 27 | @import "nav"; 28 | @import "navbar"; 29 | @import "card"; 30 | @import "accordion"; 31 | @import "breadcrumb"; 32 | @import "pagination"; 33 | @import "badge"; 34 | @import "alert"; 35 | @import "progress"; 36 | @import "list-group"; 37 | @import "close"; 38 | @import "toasts"; 39 | @import "modal"; 40 | @import "tooltip"; 41 | @import "popover"; 42 | @import "carousel"; 43 | @import "spinners"; 44 | @import "offcanvas"; 45 | @import "placeholders"; 46 | 47 | // Helpers 48 | @import "helpers"; 49 | 50 | // Utilities 51 | @import "utilities/api"; 52 | // scss-docs-end import-stack 53 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/forms/_form-text.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Form text 3 | // 4 | 5 | .form-text { 6 | margin-top: $form-text-margin-top; 7 | @include font-size($form-text-font-size); 8 | font-style: $form-text-font-style; 9 | font-weight: $form-text-font-weight; 10 | color: $form-text-color; 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/forms/_labels.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Labels 3 | // 4 | 5 | .form-label { 6 | margin-bottom: $form-label-margin-bottom; 7 | @include font-size($form-label-font-size); 8 | font-style: $form-label-font-style; 9 | font-weight: $form-label-font-weight; 10 | color: $form-label-color; 11 | } 12 | 13 | // For use with horizontal and inline forms, when you need the label (or legend) 14 | // text to align with the form controls. 15 | .col-form-label { 16 | padding-top: add($input-padding-y, $input-border-width); 17 | padding-bottom: add($input-padding-y, $input-border-width); 18 | margin-bottom: 0; // Override the `` default 19 | @include font-size(inherit); // Override the `` default 20 | font-style: $form-label-font-style; 21 | font-weight: $form-label-font-weight; 22 | line-height: $input-line-height; 23 | color: $form-label-color; 24 | } 25 | 26 | .col-form-label-lg { 27 | padding-top: add($input-padding-y-lg, $input-border-width); 28 | padding-bottom: add($input-padding-y-lg, $input-border-width); 29 | @include font-size($input-font-size-lg); 30 | } 31 | 32 | .col-form-label-sm { 33 | padding-top: add($input-padding-y-sm, $input-border-width); 34 | padding-bottom: add($input-padding-y-sm, $input-border-width); 35 | @include font-size($input-font-size-sm); 36 | } 37 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/forms/_validation.scss: -------------------------------------------------------------------------------- 1 | // Form validation 2 | // 3 | // Provide feedback to users when form field values are valid or invalid. Works 4 | // primarily for client-side validation via scoped `:invalid` and `:valid` 5 | // pseudo-classes but also includes `.is-invalid` and `.is-valid` classes for 6 | // server-side validation. 7 | 8 | // scss-docs-start form-validation-states-loop 9 | @each $state, $data in $form-validation-states { 10 | @include form-validation-state($state, $data...); 11 | } 12 | // scss-docs-end form-validation-states-loop 13 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_clearfix.scss: -------------------------------------------------------------------------------- 1 | .clearfix { 2 | @include clearfix(); 3 | } 4 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_color-bg.scss: -------------------------------------------------------------------------------- 1 | // All-caps `RGBA()` function used because of this Sass bug: https://github.com/sass/node-sass/issues/2251 2 | @each $color, $value in $theme-colors { 3 | .text-bg-#{$color} { 4 | color: color-contrast($value) if($enable-important-utilities, !important, null); 5 | background-color: RGBA(var(--#{$prefix}#{$color}-rgb), var(--#{$prefix}bg-opacity, 1)) if($enable-important-utilities, !important, null); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_colored-links.scss: -------------------------------------------------------------------------------- 1 | // All-caps `RGBA()` function used because of this Sass bug: https://github.com/sass/node-sass/issues/2251 2 | @each $color, $value in $theme-colors { 3 | .link-#{$color} { 4 | color: RGBA(var(--#{$prefix}#{$color}-rgb), var(--#{$prefix}link-opacity, 1)) if($enable-important-utilities, !important, null); 5 | text-decoration-color: RGBA(var(--#{$prefix}#{$color}-rgb), var(--#{$prefix}link-underline-opacity, 1)) if($enable-important-utilities, !important, null); 6 | 7 | @if $link-shade-percentage != 0 { 8 | &:hover, 9 | &:focus { 10 | $hover-color: if(color-contrast($value) == $color-contrast-light, shade-color($value, $link-shade-percentage), tint-color($value, $link-shade-percentage)); 11 | color: RGBA(#{to-rgb($hover-color)}, var(--#{$prefix}link-opacity, 1)) if($enable-important-utilities, !important, null); 12 | text-decoration-color: RGBA(to-rgb($hover-color), var(--#{$prefix}link-underline-opacity, 1)) if($enable-important-utilities, !important, null); 13 | } 14 | } 15 | } 16 | } 17 | 18 | // One-off special link helper as a bridge until v6 19 | .link-body-emphasis { 20 | color: RGBA(var(--#{$prefix}emphasis-color-rgb), var(--#{$prefix}link-opacity, 1)) if($enable-important-utilities, !important, null); 21 | text-decoration-color: RGBA(var(--#{$prefix}emphasis-color-rgb), var(--#{$prefix}link-underline-opacity, 1)) if($enable-important-utilities, !important, null); 22 | 23 | @if $link-shade-percentage != 0 { 24 | &:hover, 25 | &:focus { 26 | color: RGBA(var(--#{$prefix}emphasis-color-rgb), var(--#{$prefix}link-opacity, .75)) if($enable-important-utilities, !important, null); 27 | text-decoration-color: RGBA(var(--#{$prefix}emphasis-color-rgb), var(--#{$prefix}link-underline-opacity, .75)) if($enable-important-utilities, !important, null); 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_focus-ring.scss: -------------------------------------------------------------------------------- 1 | .focus-ring:focus { 2 | outline: 0; 3 | // By default, there is no `--bs-focus-ring-x`, `--bs-focus-ring-y`, or `--bs-focus-ring-blur`, but we provide CSS variables with fallbacks to initial `0` values 4 | box-shadow: var(--#{$prefix}focus-ring-x, 0) var(--#{$prefix}focus-ring-y, 0) var(--#{$prefix}focus-ring-blur, 0) var(--#{$prefix}focus-ring-width) var(--#{$prefix}focus-ring-color); 5 | } 6 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_icon-link.scss: -------------------------------------------------------------------------------- 1 | .icon-link { 2 | display: inline-flex; 3 | gap: $icon-link-gap; 4 | align-items: center; 5 | text-decoration-color: rgba(var(--#{$prefix}link-color-rgb), var(--#{$prefix}link-opacity, .5)); 6 | text-underline-offset: $icon-link-underline-offset; 7 | backface-visibility: hidden; 8 | 9 | > .bi { 10 | flex-shrink: 0; 11 | width: $icon-link-icon-size; 12 | height: $icon-link-icon-size; 13 | fill: currentcolor; 14 | @include transition($icon-link-icon-transition); 15 | } 16 | } 17 | 18 | .icon-link-hover { 19 | &:hover, 20 | &:focus-visible { 21 | > .bi { 22 | transform: var(--#{$prefix}icon-link-transform, $icon-link-icon-transform); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_position.scss: -------------------------------------------------------------------------------- 1 | // Shorthand 2 | 3 | .fixed-top { 4 | position: fixed; 5 | top: 0; 6 | right: 0; 7 | left: 0; 8 | z-index: $zindex-fixed; 9 | } 10 | 11 | .fixed-bottom { 12 | position: fixed; 13 | right: 0; 14 | bottom: 0; 15 | left: 0; 16 | z-index: $zindex-fixed; 17 | } 18 | 19 | // Responsive sticky top and bottom 20 | @each $breakpoint in map-keys($grid-breakpoints) { 21 | @include media-breakpoint-up($breakpoint) { 22 | $infix: breakpoint-infix($breakpoint, $grid-breakpoints); 23 | 24 | .sticky#{$infix}-top { 25 | position: sticky; 26 | top: 0; 27 | z-index: $zindex-sticky; 28 | } 29 | 30 | .sticky#{$infix}-bottom { 31 | position: sticky; 32 | bottom: 0; 33 | z-index: $zindex-sticky; 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_ratio.scss: -------------------------------------------------------------------------------- 1 | // Credit: Nicolas Gallagher and SUIT CSS. 2 | 3 | .ratio { 4 | position: relative; 5 | width: 100%; 6 | 7 | &::before { 8 | display: block; 9 | padding-top: var(--#{$prefix}aspect-ratio); 10 | content: ""; 11 | } 12 | 13 | > * { 14 | position: absolute; 15 | top: 0; 16 | left: 0; 17 | width: 100%; 18 | height: 100%; 19 | } 20 | } 21 | 22 | @each $key, $ratio in $aspect-ratios { 23 | .ratio-#{$key} { 24 | --#{$prefix}aspect-ratio: #{$ratio}; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_stacks.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start stacks 2 | .hstack { 3 | display: flex; 4 | flex-direction: row; 5 | align-items: center; 6 | align-self: stretch; 7 | } 8 | 9 | .vstack { 10 | display: flex; 11 | flex: 1 1 auto; 12 | flex-direction: column; 13 | align-self: stretch; 14 | } 15 | // scss-docs-end stacks 16 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_stretched-link.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Stretched link 3 | // 4 | 5 | .stretched-link { 6 | &::#{$stretched-link-pseudo-element} { 7 | position: absolute; 8 | top: 0; 9 | right: 0; 10 | bottom: 0; 11 | left: 0; 12 | z-index: $stretched-link-z-index; 13 | content: ""; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_text-truncation.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Text truncation 3 | // 4 | 5 | .text-truncate { 6 | @include text-truncate(); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_visually-hidden.scss: -------------------------------------------------------------------------------- 1 | // 2 | // Visually hidden 3 | // 4 | 5 | .visually-hidden, 6 | .visually-hidden-focusable:not(:focus):not(:focus-within) { 7 | @include visually-hidden(); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/helpers/_vr.scss: -------------------------------------------------------------------------------- 1 | .vr { 2 | display: inline-block; 3 | align-self: stretch; 4 | width: $vr-border-width; 5 | min-height: 1em; 6 | background-color: currentcolor; 7 | opacity: $hr-opacity; 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_alert.scss: -------------------------------------------------------------------------------- 1 | @include deprecate("`alert-variant()`", "v5.3.0", "v6.0.0"); 2 | 3 | // scss-docs-start alert-variant-mixin 4 | @mixin alert-variant($background, $border, $color) { 5 | --#{$prefix}alert-color: #{$color}; 6 | --#{$prefix}alert-bg: #{$background}; 7 | --#{$prefix}alert-border-color: #{$border}; 8 | --#{$prefix}alert-link-color: #{shade-color($color, 20%)}; 9 | 10 | @if $enable-gradients { 11 | background-image: var(--#{$prefix}gradient); 12 | } 13 | 14 | .alert-link { 15 | color: var(--#{$prefix}alert-link-color); 16 | } 17 | } 18 | // scss-docs-end alert-variant-mixin 19 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_backdrop.scss: -------------------------------------------------------------------------------- 1 | // Shared between modals and offcanvases 2 | @mixin overlay-backdrop($zindex, $backdrop-bg, $backdrop-opacity) { 3 | position: fixed; 4 | top: 0; 5 | left: 0; 6 | z-index: $zindex; 7 | width: 100vw; 8 | height: 100vh; 9 | background-color: $backdrop-bg; 10 | 11 | // Fade for backdrop 12 | &.fade { opacity: 0; } 13 | &.show { opacity: $backdrop-opacity; } 14 | } 15 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_banner.scss: -------------------------------------------------------------------------------- 1 | @mixin bsBanner($file) { 2 | /*! 3 | * Bootstrap #{$file} v5.3.2 (https://getbootstrap.com/) 4 | * Copyright 2011-2023 The Bootstrap Authors 5 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6 | */ 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_box-shadow.scss: -------------------------------------------------------------------------------- 1 | @mixin box-shadow($shadow...) { 2 | @if $enable-shadows { 3 | $result: (); 4 | 5 | @each $value in $shadow { 6 | @if $value != null { 7 | $result: append($result, $value, "comma"); 8 | } 9 | @if $value == none and length($shadow) > 1 { 10 | @warn "The keyword 'none' must be used as a single argument."; 11 | } 12 | } 13 | 14 | @if (length($result) > 0) { 15 | box-shadow: $result; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_caret.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start caret-mixins 2 | @mixin caret-down($width: $caret-width) { 3 | border-top: $width solid; 4 | border-right: $width solid transparent; 5 | border-bottom: 0; 6 | border-left: $width solid transparent; 7 | } 8 | 9 | @mixin caret-up($width: $caret-width) { 10 | border-top: 0; 11 | border-right: $width solid transparent; 12 | border-bottom: $width solid; 13 | border-left: $width solid transparent; 14 | } 15 | 16 | @mixin caret-end($width: $caret-width) { 17 | border-top: $width solid transparent; 18 | border-right: 0; 19 | border-bottom: $width solid transparent; 20 | border-left: $width solid; 21 | } 22 | 23 | @mixin caret-start($width: $caret-width) { 24 | border-top: $width solid transparent; 25 | border-right: $width solid; 26 | border-bottom: $width solid transparent; 27 | } 28 | 29 | @mixin caret( 30 | $direction: down, 31 | $width: $caret-width, 32 | $spacing: $caret-spacing, 33 | $vertical-align: $caret-vertical-align 34 | ) { 35 | @if $enable-caret { 36 | &::after { 37 | display: inline-block; 38 | margin-left: $spacing; 39 | vertical-align: $vertical-align; 40 | content: ""; 41 | @if $direction == down { 42 | @include caret-down($width); 43 | } @else if $direction == up { 44 | @include caret-up($width); 45 | } @else if $direction == end { 46 | @include caret-end($width); 47 | } 48 | } 49 | 50 | @if $direction == start { 51 | &::after { 52 | display: none; 53 | } 54 | 55 | &::before { 56 | display: inline-block; 57 | margin-right: $spacing; 58 | vertical-align: $vertical-align; 59 | content: ""; 60 | @include caret-start($width); 61 | } 62 | } 63 | 64 | &:empty::after { 65 | margin-left: 0; 66 | } 67 | } 68 | } 69 | // scss-docs-end caret-mixins 70 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_clearfix.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start clearfix 2 | @mixin clearfix() { 3 | &::after { 4 | display: block; 5 | clear: both; 6 | content: ""; 7 | } 8 | } 9 | // scss-docs-end clearfix 10 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_color-mode.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start color-mode-mixin 2 | @mixin color-mode($mode: light, $root: false) { 3 | @if $color-mode-type == "media-query" { 4 | @if $root == true { 5 | @media (prefers-color-scheme: $mode) { 6 | :root { 7 | @content; 8 | } 9 | } 10 | } @else { 11 | @media (prefers-color-scheme: $mode) { 12 | @content; 13 | } 14 | } 15 | } @else { 16 | [data-bs-theme="#{$mode}"] { 17 | @content; 18 | } 19 | } 20 | } 21 | // scss-docs-end color-mode-mixin 22 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_color-scheme.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start mixin-color-scheme 2 | @mixin color-scheme($name) { 3 | @media (prefers-color-scheme: #{$name}) { 4 | @content; 5 | } 6 | } 7 | // scss-docs-end mixin-color-scheme 8 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_container.scss: -------------------------------------------------------------------------------- 1 | // Container mixins 2 | 3 | @mixin make-container($gutter: $container-padding-x) { 4 | --#{$prefix}gutter-x: #{$gutter}; 5 | --#{$prefix}gutter-y: 0; 6 | width: 100%; 7 | padding-right: calc(var(--#{$prefix}gutter-x) * .5); // stylelint-disable-line function-disallowed-list 8 | padding-left: calc(var(--#{$prefix}gutter-x) * .5); // stylelint-disable-line function-disallowed-list 9 | margin-right: auto; 10 | margin-left: auto; 11 | } 12 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_deprecate.scss: -------------------------------------------------------------------------------- 1 | // Deprecate mixin 2 | // 3 | // This mixin can be used to deprecate mixins or functions. 4 | // `$enable-deprecation-messages` is a global variable, `$ignore-warning` is a variable that can be passed to 5 | // some deprecated mixins to suppress the warning (for example if the mixin is still be used in the current version of Bootstrap) 6 | @mixin deprecate($name, $deprecate-version, $remove-version, $ignore-warning: false) { 7 | @if ($enable-deprecation-messages != false and $ignore-warning != true) { 8 | @warn "#{$name} has been deprecated as of #{$deprecate-version}. It will be removed entirely in #{$remove-version}."; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_gradients.scss: -------------------------------------------------------------------------------- 1 | // Gradients 2 | 3 | // scss-docs-start gradient-bg-mixin 4 | @mixin gradient-bg($color: null) { 5 | background-color: $color; 6 | 7 | @if $enable-gradients { 8 | background-image: var(--#{$prefix}gradient); 9 | } 10 | } 11 | // scss-docs-end gradient-bg-mixin 12 | 13 | // scss-docs-start gradient-mixins 14 | // Horizontal gradient, from left to right 15 | // 16 | // Creates two color stops, start and end, by specifying a color and position for each color stop. 17 | @mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) { 18 | background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent); 19 | } 20 | 21 | // Vertical gradient, from top to bottom 22 | // 23 | // Creates two color stops, start and end, by specifying a color and position for each color stop. 24 | @mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: null, $end-percent: null) { 25 | background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent); 26 | } 27 | 28 | @mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) { 29 | background-image: linear-gradient($deg, $start-color, $end-color); 30 | } 31 | 32 | @mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) { 33 | background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color); 34 | } 35 | 36 | @mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) { 37 | background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color); 38 | } 39 | 40 | @mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) { 41 | background-image: radial-gradient(circle, $inner-color, $outer-color); 42 | } 43 | 44 | @mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) { 45 | background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent); 46 | } 47 | // scss-docs-end gradient-mixins 48 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_image.scss: -------------------------------------------------------------------------------- 1 | // Image Mixins 2 | // - Responsive image 3 | // - Retina image 4 | 5 | 6 | // Responsive image 7 | // 8 | // Keep images from scaling beyond the width of their parents. 9 | 10 | @mixin img-fluid { 11 | // Part 1: Set a maximum relative to the parent 12 | max-width: 100%; 13 | // Part 2: Override the height to auto, otherwise images will be stretched 14 | // when setting a width and height attribute on the img element. 15 | height: auto; 16 | } 17 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_list-group.scss: -------------------------------------------------------------------------------- 1 | @include deprecate("`list-group-item-variant()`", "v5.3.0", "v6.0.0"); 2 | 3 | // List Groups 4 | 5 | // scss-docs-start list-group-mixin 6 | @mixin list-group-item-variant($state, $background, $color) { 7 | .list-group-item-#{$state} { 8 | color: $color; 9 | background-color: $background; 10 | 11 | &.list-group-item-action { 12 | &:hover, 13 | &:focus { 14 | color: $color; 15 | background-color: shade-color($background, 10%); 16 | } 17 | 18 | &.active { 19 | color: $white; 20 | background-color: $color; 21 | border-color: $color; 22 | } 23 | } 24 | } 25 | } 26 | // scss-docs-end list-group-mixin 27 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_lists.scss: -------------------------------------------------------------------------------- 1 | // Lists 2 | 3 | // Unstyled keeps list items block level, just removes default browser padding and list-style 4 | @mixin list-unstyled { 5 | padding-left: 0; 6 | list-style: none; 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_pagination.scss: -------------------------------------------------------------------------------- 1 | // Pagination 2 | 3 | // scss-docs-start pagination-mixin 4 | @mixin pagination-size($padding-y, $padding-x, $font-size, $border-radius) { 5 | --#{$prefix}pagination-padding-x: #{$padding-x}; 6 | --#{$prefix}pagination-padding-y: #{$padding-y}; 7 | @include rfs($font-size, --#{$prefix}pagination-font-size); 8 | --#{$prefix}pagination-border-radius: #{$border-radius}; 9 | } 10 | // scss-docs-end pagination-mixin 11 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_reset-text.scss: -------------------------------------------------------------------------------- 1 | @mixin reset-text { 2 | font-family: $font-family-base; 3 | // We deliberately do NOT reset font-size or overflow-wrap / word-wrap. 4 | font-style: normal; 5 | font-weight: $font-weight-normal; 6 | line-height: $line-height-base; 7 | text-align: left; // Fallback for where `start` is not supported 8 | text-align: start; 9 | text-decoration: none; 10 | text-shadow: none; 11 | text-transform: none; 12 | letter-spacing: normal; 13 | word-break: normal; 14 | white-space: normal; 15 | word-spacing: normal; 16 | line-break: auto; 17 | } 18 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_resize.scss: -------------------------------------------------------------------------------- 1 | // Resize anything 2 | 3 | @mixin resizable($direction) { 4 | overflow: auto; // Per CSS3 UI, `resize` only applies when `overflow` isn't `visible` 5 | resize: $direction; // Options: horizontal, vertical, both 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_table-variants.scss: -------------------------------------------------------------------------------- 1 | // scss-docs-start table-variant 2 | @mixin table-variant($state, $background) { 3 | .table-#{$state} { 4 | $color: color-contrast(opaque($body-bg, $background)); 5 | $hover-bg: mix($color, $background, percentage($table-hover-bg-factor)); 6 | $striped-bg: mix($color, $background, percentage($table-striped-bg-factor)); 7 | $active-bg: mix($color, $background, percentage($table-active-bg-factor)); 8 | $table-border-color: mix($color, $background, percentage($table-border-factor)); 9 | 10 | --#{$prefix}table-color: #{$color}; 11 | --#{$prefix}table-bg: #{$background}; 12 | --#{$prefix}table-border-color: #{$table-border-color}; 13 | --#{$prefix}table-striped-bg: #{$striped-bg}; 14 | --#{$prefix}table-striped-color: #{color-contrast($striped-bg)}; 15 | --#{$prefix}table-active-bg: #{$active-bg}; 16 | --#{$prefix}table-active-color: #{color-contrast($active-bg)}; 17 | --#{$prefix}table-hover-bg: #{$hover-bg}; 18 | --#{$prefix}table-hover-color: #{color-contrast($hover-bg)}; 19 | 20 | color: var(--#{$prefix}table-color); 21 | border-color: var(--#{$prefix}table-border-color); 22 | } 23 | } 24 | // scss-docs-end table-variant 25 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_text-truncate.scss: -------------------------------------------------------------------------------- 1 | // Text truncate 2 | // Requires inline-block or block for proper styling 3 | 4 | @mixin text-truncate() { 5 | overflow: hidden; 6 | text-overflow: ellipsis; 7 | white-space: nowrap; 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_transition.scss: -------------------------------------------------------------------------------- 1 | // stylelint-disable property-disallowed-list 2 | @mixin transition($transition...) { 3 | @if length($transition) == 0 { 4 | $transition: $transition-base; 5 | } 6 | 7 | @if length($transition) > 1 { 8 | @each $value in $transition { 9 | @if $value == null or $value == none { 10 | @warn "The keyword 'none' or 'null' must be used as a single argument."; 11 | } 12 | } 13 | } 14 | 15 | @if $enable-transitions { 16 | @if nth($transition, 1) != null { 17 | transition: $transition; 18 | } 19 | 20 | @if $enable-reduced-motion and nth($transition, 1) != null and nth($transition, 1) != none { 21 | @media (prefers-reduced-motion: reduce) { 22 | transition: none; 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/mixins/_visually-hidden.scss: -------------------------------------------------------------------------------- 1 | // stylelint-disable declaration-no-important 2 | 3 | // Hide content visually while keeping it accessible to assistive technologies 4 | // 5 | // See: https://www.a11yproject.com/posts/2013-01-11-how-to-hide-content/ 6 | // See: https://kittygiraudel.com/2016/10/13/css-hide-and-seek/ 7 | 8 | @mixin visually-hidden() { 9 | width: 1px !important; 10 | height: 1px !important; 11 | padding: 0 !important; 12 | margin: -1px !important; // Fix for https://github.com/twbs/bootstrap/issues/25686 13 | overflow: hidden !important; 14 | clip: rect(0, 0, 0, 0) !important; 15 | white-space: nowrap !important; 16 | border: 0 !important; 17 | 18 | // Fix for positioned table caption that could become anonymous cells 19 | &:not(caption) { 20 | position: absolute !important; 21 | } 22 | } 23 | 24 | // Use to only display content when it's focused, or one of its child elements is focused 25 | // (i.e. when focus is within the element/container that the class was applied to) 26 | // 27 | // Useful for "Skip to main content" links; see https://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1 28 | 29 | @mixin visually-hidden-focusable() { 30 | &:not(:focus):not(:focus-within) { 31 | @include visually-hidden(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /node_modules/bootstrap/scss/utilities/_api.scss: -------------------------------------------------------------------------------- 1 | // Loop over each breakpoint 2 | @each $breakpoint in map-keys($grid-breakpoints) { 3 | 4 | // Generate media query if needed 5 | @include media-breakpoint-up($breakpoint) { 6 | $infix: breakpoint-infix($breakpoint, $grid-breakpoints); 7 | 8 | // Loop over each utility property 9 | @each $key, $utility in $utilities { 10 | // The utility can be disabled with `false`, thus check if the utility is a map first 11 | // Only proceed if responsive media queries are enabled or if it's the base media query 12 | @if type-of($utility) == "map" and (map-get($utility, responsive) or $infix == "") { 13 | @include generate-utility($utility, $infix); 14 | } 15 | } 16 | } 17 | } 18 | 19 | // RFS rescaling 20 | @media (min-width: $rfs-mq-value) { 21 | @each $breakpoint in map-keys($grid-breakpoints) { 22 | $infix: breakpoint-infix($breakpoint, $grid-breakpoints); 23 | 24 | @if (map-get($grid-breakpoints, $breakpoint) < $rfs-breakpoint) { 25 | // Loop over each utility property 26 | @each $key, $utility in $utilities { 27 | // The utility can be disabled with `false`, thus check if the utility is a map first 28 | // Only proceed if responsive media queries are enabled or if it's the base media query 29 | @if type-of($utility) == "map" and map-get($utility, rfs) and (map-get($utility, responsive) or $infix == "") { 30 | @include generate-utility($utility, $infix, true); 31 | } 32 | } 33 | } 34 | } 35 | } 36 | 37 | 38 | // Print utilities 39 | @media print { 40 | @each $key, $utility in $utilities { 41 | // The utility can be disabled with `false`, thus check if the utility is a map first 42 | // Then check if the utility needs print styles 43 | @if type-of($utility) == "map" and map-get($utility, print) == true { 44 | @include generate-utility($utility, "-print"); 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "bootstrap-npm", 3 | "version": "1.0.0", 4 | "lockfileVersion": 3, 5 | "requires": true, 6 | "packages": { 7 | "": { 8 | "name": "bootstrap-npm", 9 | "version": "1.0.0", 10 | "license": "ISC", 11 | "dependencies": { 12 | "bootstrap": "^5.3.2" 13 | } 14 | }, 15 | "node_modules/@popperjs/core": { 16 | "version": "2.11.8", 17 | "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz", 18 | "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==", 19 | "peer": true, 20 | "funding": { 21 | "type": "opencollective", 22 | "url": "https://opencollective.com/popperjs" 23 | } 24 | }, 25 | "node_modules/bootstrap": { 26 | "version": "5.3.2", 27 | "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.2.tgz", 28 | "integrity": "sha512-D32nmNWiQHo94BKHLmOrdjlL05q1c8oxbtBphQFb9Z5to6eGRDCm0QgeaZ4zFBHzfg2++rqa2JkqCcxDy0sH0g==", 29 | "funding": [ 30 | { 31 | "type": "github", 32 | "url": "https://github.com/sponsors/twbs" 33 | }, 34 | { 35 | "type": "opencollective", 36 | "url": "https://opencollective.com/bootstrap" 37 | } 38 | ], 39 | "peerDependencies": { 40 | "@popperjs/core": "^2.11.8" 41 | } 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "bootstrap-npm", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "scripts": { 7 | "test": "echo \"Error: no test specified\" && exit 1" 8 | }, 9 | "author": "", 10 | "license": "ISC", 11 | "dependencies": { 12 | "bootstrap": "^5.3.2" 13 | } 14 | } 15 | --------------------------------------------------------------------------------