@venite/components 0.16.7 → 0.16.13

package/dist/collection/i18n/text.i18n.en.json

@@ -0,0 +1,7 @@
+{
+  "amen": "Amen.",
+  "authorized_prayers": "Prayers and Thanksgivings",
+  "label": "Label",
+  "source": "Source",
+  "source_citation": "Citation"
+}

package/dist/collection/i18n/text.i18n.es.json

@@ -0,0 +1,3 @@
+{
+  "amen": "Amén."
+}

package/dist/collection/index.js

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './interfaces';

package/dist/collection/interfaces/add-option-to-doc.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/interfaces/dist/menu-option.js

@@ -0,0 +1,9 @@
+"use strict";
+exports.__esModule = true;
+exports.MenuOption = void 0;
+var MenuOption = /** @class */ (function () {
+    function MenuOption() {
+    }
+    return MenuOption;
+}());
+exports.MenuOption = MenuOption;

package/dist/collection/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './add-option-to-doc';
+export * from './menu-option';

package/dist/collection/interfaces/menu-option.js

@@ -0,0 +1,2 @@
+export class MenuOption {
+}

package/dist/collection/utils/element-from-path.js

@@ -0,0 +1,14 @@
+import { querySelectorDeep } from 'query-selector-shadow-dom';
+export function elementFromPath(root, path) {
+  return querySelectorDeep(`[path="${path}"]`, root);
+}
+export function insertTextInEditableText(start, end, value) {
+  let textarea = document
+    .querySelector('#editable ldf-liturgy').shadowRoot // ldf-liturgy
+    .querySelector('[path="/value/3"]').shadowRoot // ldf-liturgical-document
+    .querySelector('[path="/value/3/"]').shadowRoot // ldf-text
+    .querySelector('[path="/value/3//value/0//"]').shadowRoot // ldf-editable
+    .querySelector('textarea'); // textarea
+  textarea.setSelectionRange(start, end);
+  textarea.setRangeText(value);
+}

package/dist/{ldf/locale-d595f8f6.js → collection/utils/locale.js}

@@ -1,4 +1,4 @@
-function getComponentClosestLanguage(element) {
+export function getComponentClosestLanguage(element) {
   let closestElement = element.closest('[lang]');
   return closestElement ? closestElement.lang : 'en';
 }
@@ -13,7 +13,7 @@ function fetchLocaleStringsForComponent(componentName, locale) {
     }, () => reject());
   });
 }
-async function getLocaleComponentStrings(element) {
+export async function getLocaleComponentStrings(element) {
   let componentName = element.tagName.toLowerCase().replace('ldf-', '');
   let componentLanguage = getComponentClosestLanguage(element);
   let strings;
@@ -26,5 +26,3 @@ async function getLocaleComponentStrings(element) {
   }
   return strings;
 }
-
-export { getComponentClosestLanguage as g };

package/dist/esm/_commonjsHelpers-ba3f0406.js

@@ -0,0 +1,21 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+export { commonjsGlobal as a, createCommonjsModule as c, getDefaultExportFromCjs as g };

package/dist/{ldf/animation-6b850b6a.js → esm/animation-7a1025d0.js}

@@ -1,4 +1,4 @@
-import { r as raf } from './helpers-e9bf4204.js';
+import { r as raf } from './helpers-8c93393b.js';
 
 /**
  * Web Animations requires hyphenated CSS properties

package/dist/{ldf/app-globals-d4376e8c.js → esm/app-globals-729b03cf.js}

@@ -1,4 +1,4 @@
-import { a as appGlobalScript } from './ionic-global-98eeb119.js';
+import { a as appGlobalScript } from './ionic-global-ef89a0a5.js';
 
 const globalScripts = appGlobalScript;
 

package/dist/esm/book-31b8cdde.js

@@ -0,0 +1,282 @@
+// 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));
+            }
+        }
+    }
+}
+
+var Responsive;
+(function (Responsive) {
+    Responsive["AllSizes"] = "all";
+    Responsive["SmallOnly"] = "small-only";
+    Responsive["SmallHidden"] = "small-hidden";
+})(Responsive || (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 = {}));
+
+export { Condition as C, LiturgicalDocument as L, Responsive as R, dateOnly as a, dateFromYMDString as d };

package/dist/esm/change-ea574d32.js

@@ -0,0 +1,14 @@
+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 })));
+    }
+}
+
+export { Change as C };

package/dist/esm/cursor-0e47f111.js

@@ -0,0 +1,10 @@
+class Cursor {
+    constructor(path, start, end, element) {
+        this.path = path;
+        this.start = start;
+        this.end = end;
+        this.element = element;
+    }
+}
+
+export { Cursor as C };

package/dist/esm/gesture-controller-5bf8565e.js

@@ -0,0 +1,191 @@
+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();
+
+export { GESTURE_CONTROLLER as G };

package/dist/{ldf/haptic-0d102c16.js → esm/haptic-fc16a4d8.js}

@@ -2,10 +2,6 @@
  * Check to see if the Haptic Plugin is available
  * @return Returns `true` or false if the plugin is available
  */
-const hapticAvailable = () => {
-    const engine = window.TapticEngine;
-    return !!engine;
-};
 /**
  * Trigger a selection changed haptic event. Good for one-time events
  * (not for gestures)
@@ -44,25 +40,5 @@ const hapticSelectionEnd = () => {
         engine.gestureSelectionEnd();
     }
 };
-/**
- * Use this to indicate success/failure/warning to the user.
- * options should be of the type `{ type: 'success' }` (or `warning`/`error`)
- */
-const hapticNotification = (options) => {
-    const engine = window.TapticEngine;
-    if (engine) {
-        engine.notification(options);
-    }
-};
-/**
- * Use this to indicate success/failure/warning to the user.
- * options should be of the type `{ style: 'light' }` (or `medium`/`heavy`)
- */
-const hapticImpact = (options) => {
-    const engine = window.TapticEngine;
-    if (engine) {
-        engine.impact(options);
-    }
-};
 
 export { hapticSelectionChanged as a, hapticSelectionEnd as b, hapticSelection as c, hapticSelectionStart as h };

package/dist/esm/heading-cc5ffa8a.js

@@ -0,0 +1,19 @@
+import { L as LiturgicalDocument } from './book-31b8cdde.js';
+
+const STYLES = ['text', 'day', 'date'];
+class Heading extends LiturgicalDocument {
+    //** Constructor takes a Javascript object containing the class's properties */
+    constructor(data = {}) {
+        super(data);
+    }
+    /** Returns the list of all possible `style` values.  */
+    availableStyles() {
+        return STYLES;
+    }
+    /** No meaningful difference in display formats for this type */
+    availableDisplayFormats() {
+        return [];
+    }
+}
+
+export { Heading as H };