@venite/components 0.16.7 → 0.16.13

package/dist/cjs/app-globals-60a4f972.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const ionicGlobal = require('./ionic-global-581fb4f8.js');
+
+const globalScripts = ionicGlobal.appGlobalScript;
+
+exports.globalScripts = globalScripts;

package/dist/cjs/book-1a92678a.js

@@ -0,0 +1,287 @@
+'use strict';
+
+// strip away everything but year, month, day
+function dateOnly(d) {
+    d.setHours(0);
+    d.setMinutes(0);
+    d.setSeconds(0);
+    d.setMilliseconds(0);
+    return d;
+}
+
+/** return date from year, month (1-12), and day
+ * defaults to today if any of fields are undefined */
+function dateFromYMD(year, month, day) {
+    let d = new Date();
+    d = dateOnly(d);
+    if (year && month && day) {
+        d.setFullYear(parseInt(year));
+        d.setMonth(parseInt(month) - 1, parseInt(day));
+    }
+    return d;
+}
+/** Transforms a string like `YYYY-mm-dd` to a Date */
+function dateFromYMDString(ymd) {
+    const [y, m, d] = ymd.split('-');
+    return dateFromYMD(y, m, d);
+}
+
+class Condition {
+    //** Constructor takes a Javascript object containing the class's properties */
+    constructor(data = {}) {
+        Object.assign(this, data);
+    }
+    /** Given a liturgical day and a set of preferences, evaluates whether the condition should be included */
+    include(day, prefs = {}) {
+        var _a;
+        let include = true, evaluatedConditions = new Array(include);
+        // approach: for every possible condition included, push its truth
+        // onto evaluatedConditions — then reduce the array and require each condition given to be true
+        // `day`, `season`, and `weekday` each operate on an except/only pattern
+        // `day`: is day.slug in the `only` list (and not in the `except` list)?
+        this.exceptOnlyFactory('day', day.slug, evaluatedConditions);
+        // `week`: is day.week.slug in the `only` list (and not in the `except` list)?
+        this.exceptOnlyFactory('week', (_a = day.week) === null || _a === void 0 ? void 0 : _a.slug, evaluatedConditions);
+        // `weekday`:
+        this.exceptOnlyFactory('weekday', ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][dateFromYMDString(day.date).getDay()], evaluatedConditions);
+        // `season`: is day.week.season (the 'base season' for e.g., a saints' day in Lent)
+        // or day.season (the actual season being observed) in the `only` list (and not in `except`)?
+        if (this.hasOwnProperty('season') && this.season !== undefined) {
+            if (this.season.except !== undefined && this.season.except.length > 0) {
+                evaluatedConditions.push(!this.season.except.includes(day.season));
+                evaluatedConditions.push(!this.season.except.includes(day.week.season));
+            }
+            if (this.season.only !== undefined && this.season.only.length > 0) {
+                evaluatedConditions.push(this.season.only.includes(day.season) || this.season.only.includes(day.week.season));
+            }
+        }
+        // `feastDay`
+        if (this.hasOwnProperty('feastDay') && this.feastDay !== undefined) {
+            const highestFeastRank = Math.max(
+            // highest rank of holy days given
+            ...(day.holy_days || [])
+                .filter((a) => !!a) // exclude any null or undefined from array
+                .map((a) => (a && a.type && a.type.rank ? a.type.rank : 3))), isSunday = dateFromYMDString(day.date).getDay() == 0, isFeast = highestFeastRank >= 3 || isSunday;
+            evaluatedConditions.push(isFeast == this.feastDay);
+        }
+        // `date`
+        if (this.hasOwnProperty('date') && this.date !== undefined) {
+            const liturgyDate = dateFromYMDString(day.date);
+            for (const property in this.date) {
+                try {
+                    const [month, date] = (this.date[property] || '').split('/'), conditionDate = new Date(liturgyDate.getFullYear(), parseInt(month) - 1, parseInt(date));
+                    if (property == 'lt') {
+                        evaluatedConditions.push(liturgyDate.getTime() < conditionDate.getTime());
+                    }
+                    else if (property == 'lte') {
+                        evaluatedConditions.push(liturgyDate.getTime() <= conditionDate.getTime());
+                    }
+                    else if (property == 'gt') {
+                        evaluatedConditions.push(liturgyDate.getTime() > conditionDate.getTime());
+                    }
+                    else if (property == 'gte') {
+                        evaluatedConditions.push(liturgyDate.getTime() >= conditionDate.getTime());
+                    }
+                }
+                catch (e) {
+                    throw 'Date is formatted incorrectly (should be MM/DD).';
+                }
+            }
+        }
+        // `day_of_month`
+        if (this.hasOwnProperty('day_of_month') && this.day_of_month !== undefined) {
+            const liturgyDate = dateFromYMDString(day.date), liturgyDayOfMonth = liturgyDate.getDate();
+            for (const property in this.day_of_month) {
+                if (property == 'eq') {
+                    evaluatedConditions.push(liturgyDayOfMonth == Number(this.day_of_month.eq));
+                }
+                else if (property == 'neq') {
+                    evaluatedConditions.push(liturgyDayOfMonth != Number(this.day_of_month.neq));
+                }
+            }
+        }
+        // `preference`
+        if (this.hasOwnProperty('preference') && this.preference !== undefined) {
+            if (this.preference.is) {
+                evaluatedConditions.push(prefs[this.preference.key] == this.preference.value);
+            }
+            else {
+                evaluatedConditions.push(prefs[this.preference.key] !== this.preference.value);
+            }
+        }
+        return evaluatedConditions.reduce((a, b) => a && b, true);
+    }
+    exceptOnlyFactory(property, include, evaluatedConditions) {
+        const obj = this[property];
+        if (obj !== undefined) {
+            if (obj.except) {
+                evaluatedConditions.push(!obj.except.includes(include));
+            }
+            if (obj.only) {
+                evaluatedConditions.push(obj.only.includes(include));
+            }
+        }
+    }
+}
+
+exports.Responsive = void 0;
+(function (Responsive) {
+    Responsive["AllSizes"] = "all";
+    Responsive["SmallOnly"] = "small-only";
+    Responsive["SmallHidden"] = "small-hidden";
+})(exports.Responsive || (exports.Responsive = {}));
+const TYPES = [
+    'liturgy',
+    'heading',
+    'option',
+    'refrain',
+    'rubric',
+    'text',
+    'responsive',
+    'bible-reading',
+    'psalm',
+    'meditation',
+    'image',
+    'parallel',
+];
+const LOOKUP_TYPES = ['lectionary', 'canticle', 'category', 'slug', 'collect'];
+const DISPLAY_FORMATS = ['default', 'omit', 'unison', 'abbreviated', 'force_dropcap'];
+/** Represents a liturgy of any scope and concreteness, from a complete bullletin to a single prayer. */
+class LiturgicalDocument {
+    //** Constructor takes a Javascript object containing the class's properties */
+    constructor(data = {}) {
+        Object.assign(this, data);
+    }
+    /** Evaluates the full set of conditions attached to the document and returns a boolean of whether it should be included
+     * given the day and assigned preferences  */
+    include(day, prefs = {}) {
+        if (this.condition !== undefined) {
+            const evaluatedConditions = (this.condition.conditions || []).map((condition) => {
+                if (!(condition instanceof Condition)) {
+                    condition = new Condition(condition);
+                }
+                return condition.include(day || this.day, prefs);
+            });
+            //console.log(evaluatedConditions);
+            if (this.condition.mode == 'or') {
+                return evaluatedConditions.reduce((a, b) => a || b, false);
+            }
+            else {
+                return evaluatedConditions.reduce((a, b) => a && b, true);
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    /** Returns the list of all possible `type` values */
+    availableTypes() {
+        return TYPES;
+    }
+    /** Returns the list of all possible `style` values. Child classes should override if they have styles available. */
+    availableStyles() {
+        return [];
+    }
+    /** Returns the list of all possible `lookup.type` values */
+    availableLookupTypes() {
+        return LOOKUP_TYPES;
+    }
+    /** Returns the list of all available `display_format` values */
+    availableDisplayFormats() {
+        return DISPLAY_FORMATS;
+    }
+}
+
+var Book;
+(function (Book) {
+    Book["Genesis"] = "Genesis";
+    Book["Exodus"] = "Exodus";
+    Book["Leviticus"] = "Leviticus";
+    Book["Numbers"] = "Numbers";
+    Book["Deuteronomy"] = "Deuteronomy";
+    Book["Joshua"] = "Joshua";
+    Book["Judges"] = "Judges";
+    Book["Ruth"] = "Ruth";
+    Book["FirstSamuel"] = "FirstSamuel";
+    Book["SecondSamuel"] = "SecondSamuel";
+    Book["FirstKings"] = "FirstKings";
+    Book["SecondKings"] = "SecondKings";
+    Book["FirstChronicles"] = "FirstChronicles";
+    Book["SecondChronicles"] = "SecondChronicles";
+    Book["Ezra"] = "Ezra";
+    Book["Nehemiah"] = "Nehemiah";
+    Book["Esther"] = "Esther";
+    Book["Job"] = "Job";
+    Book["Psalms"] = "Psalms";
+    Book["Proverbs"] = "Proverbs";
+    Book["Ecclesiastes"] = "Ecclesiastes";
+    Book["SongOfSolomon"] = "SongOfSolomon";
+    Book["Isaiah"] = "Isaiah";
+    Book["Jeremiah"] = "Jeremiah";
+    Book["Lamentations"] = "Lamentations";
+    Book["Ezekiel"] = "Ezekiel";
+    Book["Daniel"] = "Daniel";
+    Book["Hosea"] = "Hosea";
+    Book["Joel"] = "Joel";
+    Book["Amos"] = "Amos";
+    Book["Obadiah"] = "Obadiah";
+    Book["Jonah"] = "Jonah";
+    Book["Micah"] = "Micah";
+    Book["Nahum"] = "Nahum";
+    Book["Habakkuk"] = "Habakkuk";
+    Book["Zephaniah"] = "Zephaniah";
+    Book["Haggai"] = "Haggai";
+    Book["Zechariah"] = "Zechariah";
+    Book["Malachi"] = "Malachi";
+    Book["Matthew"] = "Matthew";
+    Book["Mark"] = "Mark";
+    Book["Luke"] = "Luke";
+    Book["John"] = "John";
+    Book["Acts"] = "Acts";
+    Book["Romans"] = "Romans";
+    Book["FirstCorinthians"] = "FirstCorinthians";
+    Book["SecondCorinthians"] = "SecondCorinthians";
+    Book["Galatians"] = "Galatians";
+    Book["Ephesians"] = "Ephesians";
+    Book["Philippians"] = "Philippians";
+    Book["Colossians"] = "Colossians";
+    Book["FirstThessalonians"] = "FirstThessalonians";
+    Book["SecondThessalonians"] = "SecondThessalonians";
+    Book["FirstTimothy"] = "FirstTimothy";
+    Book["SecondTimothy"] = "SecondTimothy";
+    Book["Titus"] = "Titus";
+    Book["Philemon"] = "Philemon";
+    Book["Hebrews"] = "Hebrews";
+    Book["James"] = "James";
+    Book["FirstPeter"] = "FirstPeter";
+    Book["SecondPeter"] = "SecondPeter";
+    Book["FirstJohn"] = "FirstJohn";
+    Book["SecondJohn"] = "SecondJohn";
+    Book["ThirdJohn"] = "ThirdJohn";
+    Book["Jude"] = "Jude";
+    Book["Revelation"] = "Revelation";
+    Book["None"] = "None";
+    Book["Tobit"] = "Tobit";
+    Book["Judith"] = "Judith";
+    Book["Ester"] = "Ester";
+    Book["Wisdom"] = "Wisdom";
+    Book["Ecclesiasticus"] = "Ecclesiasticus";
+    Book["Baruch"] = "Baruch";
+    Book["EpistleJeremiah"] = "EpistleJeremiah";
+    Book["PrayerOfAzariah"] = "PrayerOfAzariah";
+    Book["Susanna"] = "Susanna";
+    Book["FirstMaccabees"] = "FirstMaccabees";
+    Book["SecondMaccabees"] = "SecondMaccabees";
+    Book["FirstEsdras"] = "FirstEsdras";
+    Book["SecondEsdras"] = "SecondEsdras";
+    Book["FourthEsdras"] = "FourthEsdras";
+    Book["Psalm151"] = "Psalm151";
+    Book["ThirdMaccabees"] = "ThirdMaccabees";
+    Book["FourthMaccabees"] = "FourthMaccabees";
+    Book["Bel"] = "Bel";
+})(Book || (Book = {}));
+
+exports.Condition = Condition;
+exports.LiturgicalDocument = LiturgicalDocument;
+exports.dateFromYMDString = dateFromYMDString;
+exports.dateOnly = dateOnly;

package/dist/cjs/change-cdb1e8c0.js

@@ -0,0 +1,16 @@
+'use strict';
+
+class Change {
+    //** Constructor takes a Javascript object containing the class's properties */
+    constructor(data = {}) {
+        Object.assign(this, data);
+    }
+    fullyPathedOp() {
+        const p = this.path
+            ? this.path.split('/').filter((part) => (Number(part) ? Number(part) : part))
+            : new Array();
+        return this.op.map((op) => (Object.assign(Object.assign({}, op), { p })));
+    }
+}
+
+exports.Change = Change;

package/dist/cjs/cubic-bezier-f3b34d27.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Based on:
+ * https://stackoverflow.com/questions/7348009/y-coordinate-for-a-given-x-cubic-bezier
+ * https://math.stackexchange.com/questions/26846/is-there-an-explicit-form-for-cubic-b%C3%A9zier-curves
+ * TODO: Reduce rounding error
+ */
+/**
+ * EXPERIMENTAL
+ * Given a cubic-bezier curve, get the x value (time) given
+ * the y value (progression).
+ * Ex: cubic-bezier(0.32, 0.72, 0, 1);
+ * P0: (0, 0)
+ * P1: (0.32, 0.72)
+ * P2: (0, 1)
+ * P3: (1, 1)
+ *
+ * If you give a cubic bezier curve that never reaches the
+ * provided progression, this function will return an empty array.
+ */
+const getTimeGivenProgression = (p0, p1, p2, p3, progression) => {
+    return solveCubicBezier(p0[1], p1[1], p2[1], p3[1], progression).map(tValue => {
+        return solveCubicParametricEquation(p0[0], p1[0], p2[0], p3[0], tValue);
+    });
+};
+/**
+ * Solve a cubic equation in one dimension (time)
+ */
+const solveCubicParametricEquation = (p0, p1, p2, p3, t) => {
+    const partA = (3 * p1) * Math.pow(t - 1, 2);
+    const partB = (-3 * p2 * t) + (3 * p2) + (p3 * t);
+    const partC = p0 * Math.pow(t - 1, 3);
+    return t * (partA + (t * partB)) - partC;
+};
+/**
+ * Find the `t` value for a cubic bezier using Cardano's formula
+ */
+const solveCubicBezier = (p0, p1, p2, p3, refPoint) => {
+    p0 -= refPoint;
+    p1 -= refPoint;
+    p2 -= refPoint;
+    p3 -= refPoint;
+    const roots = solveCubicEquation(p3 - 3 * p2 + 3 * p1 - p0, 3 * p2 - 6 * p1 + 3 * p0, 3 * p1 - 3 * p0, p0);
+    return roots.filter(root => root >= 0 && root <= 1);
+};
+const solveQuadraticEquation = (a, b, c) => {
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [];
+    }
+    else {
+        return [
+            (-b + Math.sqrt(discriminant)) / (2 * a),
+            (-b - Math.sqrt(discriminant)) / (2 * a)
+        ];
+    }
+};
+const solveCubicEquation = (a, b, c, d) => {
+    if (a === 0) {
+        return solveQuadraticEquation(b, c, d);
+    }
+    b /= a;
+    c /= a;
+    d /= a;
+    const p = (3 * c - b * b) / 3;
+    const q = (2 * b * b * b - 9 * b * c + 27 * d) / 27;
+    if (p === 0) {
+        return [Math.pow(-q, 1 / 3)];
+    }
+    else if (q === 0) {
+        return [Math.sqrt(-p), -Math.sqrt(-p)];
+    }
+    const discriminant = Math.pow(q / 2, 2) + Math.pow(p / 3, 3);
+    if (discriminant === 0) {
+        return [Math.pow(q / 2, 1 / 2) - b / 3];
+    }
+    else if (discriminant > 0) {
+        return [Math.pow(-(q / 2) + Math.sqrt(discriminant), 1 / 3) - Math.pow((q / 2) + Math.sqrt(discriminant), 1 / 3) - b / 3];
+    }
+    const r = Math.sqrt(Math.pow(-(p / 3), 3));
+    const phi = Math.acos(-(q / (2 * Math.sqrt(Math.pow(-(p / 3), 3)))));
+    const s = 2 * Math.pow(r, 1 / 3);
+    return [
+        s * Math.cos(phi / 3) - b / 3,
+        s * Math.cos((phi + 2 * Math.PI) / 3) - b / 3,
+        s * Math.cos((phi + 4 * Math.PI) / 3) - b / 3
+    ];
+};
+
+exports.getTimeGivenProgression = getTimeGivenProgression;

package/dist/cjs/cursor-81bfd01e.js

@@ -0,0 +1,12 @@
+'use strict';
+
+class Cursor {
+    constructor(path, start, end, element) {
+        this.path = path;
+        this.start = start;
+        this.end = end;
+        this.element = element;
+    }
+}
+
+exports.Cursor = Cursor;

package/dist/cjs/focus-visible-5621d6b1.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const ION_FOCUSED = 'ion-focused';
+const ION_FOCUSABLE = 'ion-focusable';
+const FOCUS_KEYS = ['Tab', 'ArrowDown', 'Space', 'Escape', ' ', 'Shift', 'Enter', 'ArrowLeft', 'ArrowRight', 'ArrowUp'];
+const startFocusVisible = () => {
+    let currentFocus = [];
+    let keyboardMode = true;
+    const doc = document;
+    const setFocus = (elements) => {
+        currentFocus.forEach(el => el.classList.remove(ION_FOCUSED));
+        elements.forEach(el => el.classList.add(ION_FOCUSED));
+        currentFocus = elements;
+    };
+    const pointerDown = () => {
+        keyboardMode = false;
+        setFocus([]);
+    };
+    doc.addEventListener('keydown', ev => {
+        keyboardMode = FOCUS_KEYS.includes(ev.key);
+        if (!keyboardMode) {
+            setFocus([]);
+        }
+    });
+    doc.addEventListener('focusin', ev => {
+        if (keyboardMode && ev.composedPath) {
+            const toFocus = ev.composedPath().filter((el) => {
+                if (el.classList) {
+                    return el.classList.contains(ION_FOCUSABLE);
+                }
+                return false;
+            });
+            setFocus(toFocus);
+        }
+    });
+    doc.addEventListener('focusout', () => {
+        if (doc.activeElement === doc.body) {
+            setFocus([]);
+        }
+    });
+    doc.addEventListener('touchstart', pointerDown);
+    doc.addEventListener('mousedown', pointerDown);
+};
+
+exports.startFocusVisible = startFocusVisible;

package/dist/cjs/framework-delegate-84d33ff0.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const attachComponent = async (delegate, container, component, cssClasses, componentProps) => {
+    if (delegate) {
+        return delegate.attachViewToDom(container, component, componentProps, cssClasses);
+    }
+    if (typeof component !== 'string' && !(component instanceof HTMLElement)) {
+        throw new Error('framework delegate is missing');
+    }
+    const el = (typeof component === 'string')
+        ? container.ownerDocument && container.ownerDocument.createElement(component)
+        : component;
+    if (cssClasses) {
+        cssClasses.forEach(c => el.classList.add(c));
+    }
+    if (componentProps) {
+        Object.assign(el, componentProps);
+    }
+    container.appendChild(el);
+    if (el.componentOnReady) {
+        await el.componentOnReady();
+    }
+    return el;
+};
+const detachComponent = (delegate, element) => {
+    if (element) {
+        if (delegate) {
+            const container = element.parentElement;
+            return delegate.removeViewFromDom(container, element);
+        }
+        element.remove();
+    }
+    return Promise.resolve();
+};
+
+exports.attachComponent = attachComponent;
+exports.detachComponent = detachComponent;

package/dist/cjs/gesture-controller-5bd9d825.js

@@ -0,0 +1,193 @@
+'use strict';
+
+class GestureController {
+    constructor() {
+        this.gestureId = 0;
+        this.requestedStart = new Map();
+        this.disabledGestures = new Map();
+        this.disabledScroll = new Set();
+    }
+    /**
+     * Creates a gesture delegate based on the GestureConfig passed
+     */
+    createGesture(config) {
+        return new GestureDelegate(this, this.newID(), config.name, config.priority || 0, !!config.disableScroll);
+    }
+    /**
+     * Creates a blocker that will block any other gesture events from firing. Set in the ion-gesture component.
+     */
+    createBlocker(opts = {}) {
+        return new BlockerDelegate(this, this.newID(), opts.disable, !!opts.disableScroll);
+    }
+    start(gestureName, id, priority) {
+        if (!this.canStart(gestureName)) {
+            this.requestedStart.delete(id);
+            return false;
+        }
+        this.requestedStart.set(id, priority);
+        return true;
+    }
+    capture(gestureName, id, priority) {
+        if (!this.start(gestureName, id, priority)) {
+            return false;
+        }
+        const requestedStart = this.requestedStart;
+        let maxPriority = -10000;
+        requestedStart.forEach(value => {
+            maxPriority = Math.max(maxPriority, value);
+        });
+        if (maxPriority === priority) {
+            this.capturedId = id;
+            requestedStart.clear();
+            const event = new CustomEvent('ionGestureCaptured', { detail: { gestureName } });
+            document.dispatchEvent(event);
+            return true;
+        }
+        requestedStart.delete(id);
+        return false;
+    }
+    release(id) {
+        this.requestedStart.delete(id);
+        if (this.capturedId === id) {
+            this.capturedId = undefined;
+        }
+    }
+    disableGesture(gestureName, id) {
+        let set = this.disabledGestures.get(gestureName);
+        if (set === undefined) {
+            set = new Set();
+            this.disabledGestures.set(gestureName, set);
+        }
+        set.add(id);
+    }
+    enableGesture(gestureName, id) {
+        const set = this.disabledGestures.get(gestureName);
+        if (set !== undefined) {
+            set.delete(id);
+        }
+    }
+    disableScroll(id) {
+        this.disabledScroll.add(id);
+        if (this.disabledScroll.size === 1) {
+            document.body.classList.add(BACKDROP_NO_SCROLL);
+        }
+    }
+    enableScroll(id) {
+        this.disabledScroll.delete(id);
+        if (this.disabledScroll.size === 0) {
+            document.body.classList.remove(BACKDROP_NO_SCROLL);
+        }
+    }
+    canStart(gestureName) {
+        if (this.capturedId !== undefined) {
+            // a gesture already captured
+            return false;
+        }
+        if (this.isDisabled(gestureName)) {
+            return false;
+        }
+        return true;
+    }
+    isCaptured() {
+        return this.capturedId !== undefined;
+    }
+    isScrollDisabled() {
+        return this.disabledScroll.size > 0;
+    }
+    isDisabled(gestureName) {
+        const disabled = this.disabledGestures.get(gestureName);
+        if (disabled && disabled.size > 0) {
+            return true;
+        }
+        return false;
+    }
+    newID() {
+        this.gestureId++;
+        return this.gestureId;
+    }
+}
+class GestureDelegate {
+    constructor(ctrl, id, name, priority, disableScroll) {
+        this.id = id;
+        this.name = name;
+        this.disableScroll = disableScroll;
+        this.priority = priority * 1000000 + id;
+        this.ctrl = ctrl;
+    }
+    canStart() {
+        if (!this.ctrl) {
+            return false;
+        }
+        return this.ctrl.canStart(this.name);
+    }
+    start() {
+        if (!this.ctrl) {
+            return false;
+        }
+        return this.ctrl.start(this.name, this.id, this.priority);
+    }
+    capture() {
+        if (!this.ctrl) {
+            return false;
+        }
+        const captured = this.ctrl.capture(this.name, this.id, this.priority);
+        if (captured && this.disableScroll) {
+            this.ctrl.disableScroll(this.id);
+        }
+        return captured;
+    }
+    release() {
+        if (this.ctrl) {
+            this.ctrl.release(this.id);
+            if (this.disableScroll) {
+                this.ctrl.enableScroll(this.id);
+            }
+        }
+    }
+    destroy() {
+        this.release();
+        this.ctrl = undefined;
+    }
+}
+class BlockerDelegate {
+    constructor(ctrl, id, disable, disableScroll) {
+        this.id = id;
+        this.disable = disable;
+        this.disableScroll = disableScroll;
+        this.ctrl = ctrl;
+    }
+    block() {
+        if (!this.ctrl) {
+            return;
+        }
+        if (this.disable) {
+            for (const gesture of this.disable) {
+                this.ctrl.disableGesture(gesture, this.id);
+            }
+        }
+        if (this.disableScroll) {
+            this.ctrl.disableScroll(this.id);
+        }
+    }
+    unblock() {
+        if (!this.ctrl) {
+            return;
+        }
+        if (this.disable) {
+            for (const gesture of this.disable) {
+                this.ctrl.enableGesture(gesture, this.id);
+            }
+        }
+        if (this.disableScroll) {
+            this.ctrl.enableScroll(this.id);
+        }
+    }
+    destroy() {
+        this.unblock();
+        this.ctrl = undefined;
+    }
+}
+const BACKDROP_NO_SCROLL = 'backdrop-no-scroll';
+const GESTURE_CONTROLLER = new GestureController();
+
+exports.GESTURE_CONTROLLER = GESTURE_CONTROLLER;