@betorigami/games 0.0.1

package/dist/origami.svg

@@ -0,0 +1,17 @@
+<svg width="777" height="189" viewBox="0 0 777 189" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_11769_64)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M188.68 72.35V0H116.33C112.51 0 108.91 1.78 106.59 4.8L94.59 20.45L82.6 4.8C80.27 1.78 76.67 0 72.86 0H0.5V72.35C0.5 76.17 2.28 79.77 5.31 82.09L20.96 94.09L5.31 106.08C2.28 108.41 0.5 112.01 0.5 115.82V188.18H72.86C76.67 188.18 80.27 186.4 82.6 183.37L94.59 167.72L106.59 183.37C108.91 186.4 112.51 188.18 116.33 188.18H188.68V115.82C188.68 112.01 186.9 108.41 183.88 106.08L168.23 94.09L183.88 82.09C186.9 79.77 188.68 76.17 188.68 72.35ZM111.06 110.55C96.94 124.67 94.59 141.13 94.59 141.13C94.59 141.13 92.24 124.67 78.13 110.55C64.01 96.44 47.55 94.09 47.55 94.09C47.55 94.09 64.01 91.74 78.13 77.62C92.24 63.51 94.59 47.04 94.59 47.04C94.59 47.04 96.94 63.51 111.06 77.62C125.17 91.74 141.64 94.09 141.64 94.09C141.64 94.09 125.17 96.44 111.06 110.55Z" fill="#b3b3b3"/>
+<path d="M235.725 93.693C235.725 61.653 257.227 38.022 290.704 38.022C324.181 38.022 345.843 61.653 345.843 93.693C345.843 125.733 325.246 150.056 290.704 150.056C256.162 150.056 235.725 125.893 235.725 93.693ZM325.405 93.48C325.405 72.883 313.217 56.437 290.704 56.437C268.191 56.437 256.003 72.883 256.003 93.48C256.003 116.046 267.978 131.588 290.704 131.588C313.43 131.588 325.405 115.994 325.405 93.48Z" fill="#b3b3b3"/>
+<path d="M354.252 147.714V63.569H373.572V91.138H373.944C377.723 69.317 385.228 63.569 397.948 63.569H402.791V85.231H394.542C379.48 85.231 373.625 90.447 373.625 105.083V147.661H354.305L354.252 147.714Z" fill="#b3b3b3"/>
+<path d="M408.805 52.339V38.022H429.722V52.339H408.805ZM409.71 147.714V63.569H429.03V147.714H409.71Z" fill="#b3b3b3"/>
+<path d="M436.056 157.401C436.056 150.216 443.028 144.68 456.121 143.084C447.871 142.019 443.241 138.081 443.241 131.8C443.241 127.489 447.019 123.018 453.779 120.73L460.219 117.856C447.711 113.918 440.899 104.976 440.899 92.415C440.899 74 454.311 63.621 477.037 63.621H518.178V79.907H507.268C503.169 79.907 499.018 79.907 493.11 79.534V79.694C503.489 81.663 511.366 86.134 511.366 97.417C511.366 112.266 499.018 119.983 476.132 119.983C470.757 119.983 465.914 119.451 461.656 118.173L459.846 121.047C458.782 122.857 457.877 123.921 457.877 125.358C457.877 128.551 460.219 129.829 465.222 129.829C475.228 129.829 485.979 129.297 495.292 129.297C513.175 129.297 520.733 137.174 520.733 150.214C520.733 165.967 509.822 174.749 477.942 174.536C445.21 174.696 436.056 167.937 436.056 157.345V157.399V157.401ZM505.298 150.216C505.298 146.437 502.957 143.243 495.984 143.243H463.785C455.003 143.243 451.064 147.341 451.064 151.493C451.064 157.933 456.067 160.275 477.569 160.275C500.455 160.275 505.298 157.081 505.298 150.269V150.216ZM458.249 93.48C458.249 101.889 463.093 107.265 476.345 107.265C489.597 107.265 494.76 102.049 494.76 93.48C494.76 84.911 488.693 79.536 476.132 79.536C463.571 79.536 458.249 85.071 458.249 93.48Z" fill="#b3b3b3"/>
+<path d="M579.225 126.585H578.852C574.914 141.593 564.695 149.47 550.218 149.47C534.624 149.47 523.713 141.593 523.713 125.467C523.713 109.341 533.027 98.962 554.157 98.962H579.225V95.556C579.225 84.113 574.594 77.833 562.938 77.833C552.56 77.833 546.652 82.463 544.683 94.651L526.268 92.15C528.769 73.362 539.893 61.707 563.684 61.707C587.475 61.707 598.385 73.895 598.385 95.344V147.609H579.225V126.479V126.585ZM579.225 116.047V113.386H557.031C547.717 113.386 542.714 116.792 542.714 122.54C542.714 128.288 546.493 133.823 557.403 133.823C570.656 133.823 579.225 126.319 579.225 116.1V116.047Z" fill="#b3b3b3"/>
+<path d="M629.893 147.715H610.573V63.57H629.893V86.669H630.052C633.831 68.786 644.529 61.441 658.686 61.441C676.941 61.441 684.978 72.192 686.415 87.733H686.575C689.981 68.945 699.667 61.441 715.049 61.441C735.646 61.441 743.15 74.693 743.15 92.949V147.716H723.99V97.952C723.99 87.733 719.307 78.792 706.267 78.792C693.919 78.792 686.575 85.977 686.575 97.952V147.716H667.255V97.952C667.255 87.733 662.784 78.792 649.691 78.792C637.344 78.792 629.839 85.977 629.839 97.952V147.716H629.893V147.715Z" fill="#b3b3b3"/>
+<path d="M755.605 52.339V38.022H776.521V52.339H755.605ZM756.51 147.714V63.569H775.829V147.714H756.51Z" fill="#b3b3b3"/>
+</g>
+<defs>
+<clipPath id="clip0_11769_64">
+<rect width="776.021" height="188.18" fill="white" transform="translate(0.5)"/>
+</clipPath>
+</defs>
+</svg>

package/dist/shared/component.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/dist/shared/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const CRYPTO_DECIMALS = 8;
+export declare const FIAT_DECIMALS = 2;
+export declare const EDGE_BPS = 100;
+export declare enum Currency {
+    BTC = "BTC",
+    ETH = "ETH",
+    USDC = "USDC"
+}

package/dist/shared/event-map.d.ts

@@ -0,0 +1,126 @@
+import { KenoRiskLevel } from 'shufflecom-calculations';
+import { GameType } from '../components/shared/BetResultModal/BetResultModal';
+import { BetMode } from '../components/shared/GameSidebar/GameSidebar';
+import { AutobetValues } from '../components/shared/GenericAutobet/GenericAutobet';
+import { Currency } from './constants';
+export type MinesCountChangeEvent = CustomEvent<{
+    count: number;
+}>;
+export type BetModeChangeEvent = CustomEvent<{
+    tab: BetMode;
+}>;
+export type MinesTileChosenEvent = CustomEvent<{
+    tile: number;
+}>;
+export type InputChangeEvent = CustomEvent<{
+    value: string;
+    target: HTMLInputElement;
+}>;
+export type AutobetToggleEvent = CustomEvent<AutobetValues & {
+    numberOfBets: string;
+}>;
+export type SliderChangeEvent = CustomEvent<{
+    value: number;
+}>;
+export type DiceMultiplierChangeEvent = CustomEvent<{
+    multiplier: string;
+}>;
+export type DiceWinChanceChangeEvent = CustomEvent<{
+    winChance: string;
+}>;
+export type LimboMultiplierChangeEvent = CustomEvent<{
+    multiplier: string;
+}>;
+export type LimboWinChanceChangeEvent = CustomEvent<{
+    winChance: string;
+}>;
+export type LimboMultiplierAnimationEndEvent = CustomEvent<{
+    resultMultiplier: number;
+    isWin: boolean;
+    betId: string;
+}>;
+export type InputBlurEvent = CustomEvent<{
+    value: string;
+}>;
+export type RawCurrencyInputChangeEvent = CustomEvent<{
+    value: string;
+}>;
+export type SelectEvent = CustomEvent<{
+    value: string;
+    originalEvent: Event;
+}>;
+export type ButtonClickEvent = CustomEvent<{
+    originalEvent: MouseEvent;
+}>;
+export type ToggleChangeEvent = CustomEvent<{
+    value: string;
+}>;
+export type BetCountChangeEvent = CustomEvent<{
+    value: number;
+}>;
+export type KenoRiskChangeEvent = CustomEvent<{
+    value: KenoRiskLevel;
+}>;
+export type KenoTileClickEvent = CustomEvent<{
+    tile: number;
+}>;
+export type KenoGridClickEvent = CustomEvent;
+export type BalanceChangeEvent = CustomEvent<{
+    balance: number;
+    currency: Currency;
+}>;
+export type OpenBetResultModalEvent = CustomEvent<{
+    gameType: GameType;
+    betId: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "bet-mode-change": BetModeChangeEvent;
+        "mines-count-change": MinesCountChangeEvent;
+        "mines-tile-selected": MinesTileChosenEvent;
+        "mines-manual-start": CustomEvent;
+        "mines-cashout": CustomEvent;
+        "mines-choose-random-tile": CustomEvent;
+        "autobet-toggle": AutobetToggleEvent;
+        "bet-count-change": BetCountChangeEvent;
+        "modal-after-hide": CustomEvent;
+        "modal-after-show": CustomEvent;
+        "modal-hide": CustomEvent;
+        "modal-initial-focus": CustomEvent;
+        "modal-request-close": CustomEvent;
+        "modal-show": CustomEvent;
+        "input-change": InputChangeEvent;
+        "input-focus": CustomEvent;
+        "input-click": CustomEvent;
+        "input-blur": InputBlurEvent;
+        "raw-currency-input-change": RawCurrencyInputChangeEvent;
+        "raw-currency-input-blur": CustomEvent;
+        "raw-currency-input-focus": CustomEvent;
+        "currency-input-change": InputChangeEvent;
+        "slider-input-change": SliderChangeEvent;
+        "select-change": SelectEvent;
+        "button-click": ButtonClickEvent;
+        "dice-multiplier-change": DiceMultiplierChangeEvent;
+        "dice-win-chance-change": DiceWinChanceChangeEvent;
+        "dice-roll-over-toggle": CustomEvent;
+        "dice-manual-play": CustomEvent;
+        "footer-settings-click": CustomEvent;
+        "footer-theatre-click": CustomEvent;
+        "footer-stats-click": CustomEvent;
+        "footer-favorites-click": CustomEvent;
+        "footer-provably-fair-click": CustomEvent;
+        "toggle-change": ToggleChangeEvent;
+        "limbo-multiplier-change": LimboMultiplierChangeEvent;
+        "limbo-win-chance-change": LimboWinChanceChangeEvent;
+        "limbo-multiplier-animation-end": LimboMultiplierAnimationEndEvent;
+        "keno-auto-pick": CustomEvent;
+        "keno-clear-table": CustomEvent;
+        "keno-manual-play": CustomEvent;
+        "keno-risk-change": KenoRiskChangeEvent;
+        "keno-tile-click": KenoTileClickEvent;
+        "keno-grid-click": KenoGridClickEvent;
+        "limbo-manual-play": CustomEvent;
+        "open-bet-result-modal": OpenBetResultModalEvent;
+        "balance-change": BalanceChangeEvent;
+    }
+}

package/dist/shared/get-game-outcome.d.ts

@@ -0,0 +1 @@
+export declare const getGameOutcome: (multiplier: number) => "Draw" | "Win" | "Loss";

package/dist/shared/icons/diceCubeIcon.d.ts

@@ -0,0 +1 @@
+export declare const diceCubeSvg: import('lit').TemplateResult<2>;

package/dist/shared/icons/minesBombIcon.d.ts

@@ -0,0 +1 @@
+export declare const minesBombIcon: import('lit').TemplateResult<2>;

package/dist/shared/icons/minesGemIcon.d.ts

@@ -0,0 +1 @@
+export declare const minesGemIcon: import('lit').TemplateResult<2>;

package/dist/shared/icons/multiplierIcon.d.ts

@@ -0,0 +1 @@
+export declare const multiplierIcon: import('lit').TemplateResult<2>;

package/dist/shared/icons/profitIcon.d.ts

@@ -0,0 +1 @@
+export declare const profitIcon: import('lit').TemplateResult<2>;

package/dist/shared/icons/rollDirectionIcon.d.ts

@@ -0,0 +1 @@
+export declare const rollDirectionIcon: import('lit').TemplateResult<2>;

package/dist/shared/icons/winChanceIcon.d.ts

@@ -0,0 +1 @@
+export declare const winChanceIcon: import('lit').TemplateResult<2>;

package/dist/shared/origami-action.type.d.ts

@@ -0,0 +1,7 @@
+export declare enum OrigamiActionType {
+    START_BET = "START_BET",// bet started but not yet ended send to the /bet webhook
+    END_BET = "END_BET",// bet has been completed. Can be started and ended in 1 webhook or started in 1 and ended in another. send to the /bet webhook
+    ROLLBACK = "ROLLBACK",// send to the /rollback webhook
+    INTERMEDIATE_BET_ACTION = "INTERMEDIATE_BET_ACTION",// bet amount was increased without game ending, such as doubling down in blackjack
+    INTERMEDIATE_NON_BET_ACTION = "INTERMEDIATE_NON_BET_ACTION"
+}

package/dist/shared/origami-element.d.ts

@@ -0,0 +1,21 @@
+import { CSSResult, LitElement } from 'lit';
+type EventTypeRequiresDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? never : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? never : T : never : never;
+type EventTypeDoesNotRequireDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? T : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? T : never : T : T;
+type EventTypesWithRequiredDetail = {
+    [EventType in keyof GlobalEventHandlersEventMap as EventTypeRequiresDetail<EventType>]: true;
+};
+type EventTypesWithoutRequiredDetail = {
+    [EventType in keyof GlobalEventHandlersEventMap as EventTypeDoesNotRequireDetail<EventType>]: true;
+};
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type SlEventInit<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]> : Partial<GlobalEventHandlersEventMap[T]["detail"]> extends GlobalEventHandlersEventMap[T]["detail"] ? CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]> : WithRequired<CustomEventInit<GlobalEventHandlersEventMap[T]["detail"]>, "detail"> : CustomEventInit : CustomEventInit;
+type GetCustomEventType<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<unknown> ? GlobalEventHandlersEventMap[T] : CustomEvent<unknown> : CustomEvent<unknown>;
+export default class OrigamiElement extends LitElement {
+    static componentStyles: CSSResult[];
+    /** Emits a custom event with more convenient defaults. */
+    emit<T extends string & keyof EventTypesWithoutRequiredDetail>(name: EventTypeDoesNotRequireDetail<T>, options?: SlEventInit<T> | undefined): GetCustomEventType<T>;
+    emit<T extends string & keyof EventTypesWithRequiredDetail>(name: EventTypeRequiresDetail<T>, options: SlEventInit<T>): GetCustomEventType<T>;
+}
+export {};

package/dist/shared/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/shared/watch.d.ts

@@ -0,0 +1,26 @@
+import { LitElement } from 'lit';
+type UpdateHandler = (prev?: unknown, next?: unknown) => void;
+type NonUndefined<A> = A extends undefined ? never : A;
+type UpdateHandlerFunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends UpdateHandler ? K : never;
+}[keyof T];
+interface WatchOptions {
+    /**
+     * If true, will only start watching after the initial update/render
+     */
+    waitUntilFirstUpdate?: boolean;
+}
+/**
+ * Runs when observed properties change, e.g. @property or @state, but before the component updates. To wait for an
+ * update to complete after a change occurs, use `await this.updateComplete` in the handler. To start watching after the
+ * initial update/render, use `{ waitUntilFirstUpdate: true }` or `this.hasUpdated` in the handler.
+ *
+ * Usage:
+ *
+ * @watch('propName')
+ * handlePropChange(oldValue, newValue) {
+ *   ...
+ * }
+ */
+export declare function watch(propertyName: string | string[], options?: WatchOptions): <ElemClass extends LitElement>(proto: ElemClass, decoratedFnName: UpdateHandlerFunctionKeys<ElemClass>) => void;
+export {};

package/dist/utils/active-elements.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use a generator so we can iterate and possibly break early.
+ * @example
+ *   // to operate like a regular array. This kinda nullifies generator benefits, but worth knowing if you need the whole array.
+ *   const allActiveElements = [...activeElements()]
+ *
+ *   // Early return
+ *   for (const activeElement of activeElements()) {
+ *     if (<cond>) {
+ *       break; // Break the loop, dont need to iterate over the whole array or store an array in memory!
+ *     }
+ *   }
+ */
+export declare function activeElements(activeElement?: Element | null): Generator<Element>;
+export declare function getDeepestActiveElement(): Element | undefined;

package/dist/utils/animate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Animates an element using keyframes. Returns a promise that resolves after the animation completes or gets canceled.
+ */
+export declare function animateTo(el: HTMLElement, keyframes: Keyframe[], options?: KeyframeAnimationOptions): Promise<unknown>;
+/** Parses a CSS duration and returns the number of milliseconds. */
+export declare function parseDuration(delay: number | string): number;
+/** Tells if the user has enabled the "reduced motion" setting in their browser or OS. */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Stops all active animations on the target element. Returns a promise that resolves after all animations are canceled.
+ */
+export declare function stopAnimations(el: HTMLElement): Promise<unknown[]>;
+/**
+ * We can't animate `height: auto`, but we can calculate the height and shim keyframes by replacing it with the
+ * element's scrollHeight before the animation.
+ */
+export declare function shimKeyframesHeightAuto(keyframes: Keyframe[], calculatedHeight: number): {
+    height: string | number | null | undefined;
+    composite?: CompositeOperationOrAuto;
+    easing?: string;
+    offset?: number | null;
+}[];

package/dist/utils/animation-registry.d.ts

@@ -0,0 +1,24 @@
+export interface ElementAnimation {
+    keyframes: Keyframe[];
+    rtlKeyframes?: Keyframe[];
+    options?: KeyframeAnimationOptions;
+}
+export interface ElementAnimationMap {
+    [animationName: string]: ElementAnimation;
+}
+export interface GetAnimationOptions {
+    /**
+     * The component's directionality. When set to "rtl", `rtlKeyframes` will be preferred over `keyframes` where
+     * available using getAnimation().
+     */
+    dir: string;
+}
+/**
+ * Sets a default animation. Components should use the `name.animation` for primary animations and `name.part.animation`
+ * for secondary animations, e.g. `dialog.show` and `dialog.overlay.show`. For modifiers, use `drawer.showTop`.
+ */
+export declare function setDefaultAnimation(animationName: string, animation: ElementAnimation | null): void;
+/** Sets a custom animation for the specified element. */
+export declare function setAnimation(el: Element, animationName: string, animation: ElementAnimation | null): void;
+/** Gets an element's animation. Falls back to the default if no animation is found. */
+export declare function getAnimation(el: Element, animationName: string, options: GetAnimationOptions): ElementAnimation;

package/dist/utils/event.d.ts

@@ -0,0 +1,2 @@
+/** Waits for a specific event to be emitted from an element. Ignores events that bubble up from child elements. */
+export declare function waitForEvent(el: HTMLElement, eventName: keyof GlobalEventHandlersEventMap): Promise<void>;

package/dist/utils/focus-trap.d.ts

@@ -0,0 +1,24 @@
+export default class FocusTrap {
+    element: HTMLElement;
+    isExternalActivated: boolean;
+    tabDirection: 'forward' | 'backward';
+    currentFocus: HTMLElement | null;
+    previousFocus: HTMLElement | null;
+    elementsWithTabbableControls: string[];
+    constructor(element: HTMLElement);
+    /** Activates focus trapping. */
+    activate(): void;
+    /** Deactivates focus trapping. */
+    deactivate(): void;
+    /** Determines if this modal element is currently active or not. */
+    isActive(): boolean;
+    /** Activates external modal behavior and temporarily disables focus trapping. */
+    activateExternal(): void;
+    /** Deactivates external modal behavior and re-enables focus trapping. */
+    deactivateExternal(): void;
+    private checkFocus;
+    private handleFocusIn;
+    private possiblyHasTabbableChildren;
+    private handleKeyDown;
+    private handleKeyUp;
+}

package/dist/utils/scroll.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns an element's offset relative to its parent. Similar to element.offsetTop and element.offsetLeft, except the
+ * parent doesn't have to be positioned relative or absolute.
+ *
+ * NOTE: This was created to work around what appears to be a bug in Chrome where a slotted element's offsetParent seems
+ * to ignore elements inside the surrounding shadow DOM: https://bugs.chromium.org/p/chromium/issues/detail?id=920069
+ */
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};
+/**
+ * Prevents body scrolling. Keeps track of which elements requested a lock so multiple levels of locking are possible
+ * without premature unlocking.
+ */
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+/**
+ * Unlocks body scrolling. Scrolling will only be unlocked once all elements that requested a lock call this method.
+ */
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+/** Scrolls an element into view of its container. If the element is already in view, nothing will happen. */
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: "horizontal" | "vertical" | "both", behavior?: "smooth" | "auto"): void;

package/dist/utils/slot.controller.d.ts

@@ -0,0 +1,23 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A reactive controller that determines when slots exist. */
+export declare class HasSlotController implements ReactiveController {
+    host: ReactiveControllerHost & Element;
+    slotNames: string[];
+    constructor(host: ReactiveControllerHost & Element, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    test(slotName: string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private handleSlotChange;
+}
+/**
+ * Given a slot, this function iterates over all of its assigned element and text nodes and returns the concatenated
+ * HTML as a string. This is useful because we can't use slot.innerHTML as an alternative.
+ */
+export declare function getInnerHTML(slot: HTMLSlotElement): string;
+/**
+ * Given a slot, this function iterates over all of its assigned text nodes and returns the concatenated text as a
+ * string. This is useful because we can't use slot.textContent as an alternative.
+ */
+export declare function getTextContent(slot: HTMLSlotElement | undefined | null): string;

package/dist/utils/tabbable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the first and last bounding elements that are tabbable. This is more performant than checking every single
+ * element because it short-circuits after finding the first and last ones.
+ */
+export declare function getTabbableBoundary(root: HTMLElement | ShadowRoot): {
+    start: HTMLElement;
+    end: HTMLElement;
+};
+export declare function getTabbableElements(root: HTMLElement | ShadowRoot): HTMLElement[];

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@betorigami/games",
+  "version": "0.0.1",
+  "author": "",
+  "license": "UNLICENSED",
+  "description": "",
+  "type": "module",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "unpkg": "dist/index.umd.js",
+  "jsdelivr": "dist/index.umd.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@lit/context": "^1.1.5",
+    "bignumber.js": "^9.3.0",
+    "lit": "^3.3.0",
+    "shufflecom-calculations": "^1.14.10",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@storybook/test": "^8.6.14",
+    "@storybook/web-components": "^9.0.4",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "scripts": {
+    "build": "tsc && vite build",
+    "watch": "vite",
+    "preview": "vite preview"
+  }
+}