@santi020k/lumen-core 3.0.0 → 4.0.0

package/dist/ai-surfaces.js

@@ -0,0 +1,162 @@
+export const readLumenPromptSubmitDetail = (value) => {
+    if (typeof value === 'object' && value !== null && 'text' in value && typeof value.text === 'string')
+        return { text: value.text };
+    return undefined;
+};
+export const readLumenApprovalResponseDetail = (value) => {
+    if (typeof value !== 'object' || value === null || !('requestId' in value) || typeof value.requestId !== 'string' || !('response' in value))
+        return undefined;
+    if (value.response === 'approve' || value.response === 'reject')
+        return { requestId: value.requestId, response: value.response };
+    return undefined;
+};
+export const normalizeLumenPromptLimit = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1)
+        return 4000;
+    return Math.min(2147483647, Math.floor(value));
+};
+export const canSubmitLumenPrompt = (text, limit = 4000) => (text.trim().length > 0 && text.length <= normalizeLumenPromptLimit(limit));
+const hasUnsafeCitationCharacter = (value) => {
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code <= 32 || code === 127 || code === 92)
+            return true;
+    }
+    return false;
+};
+const webCitationHref = (value) => {
+    try {
+        const url = new URL(value);
+        if ((url.protocol === 'https:' || url.protocol === 'http:') && !url.username && !url.password)
+            return url.href;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+};
+/** Citations accept safe web destinations and local absolute paths, never executable schemes. */
+export const resolveLumenCitationHref = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    if (hasUnsafeCitationCharacter(value))
+        return undefined;
+    if (value.startsWith('/') && !value.startsWith('//'))
+        return value;
+    return webCitationHref(value);
+};
+const isPlainSubmitKey = (event) => event.key === 'Enter' && !event.defaultPrevented && !event.isComposing &&
+    !event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey;
+/** Bind an event bridge. A supplied native action keeps its normal POST behavior. */
+export const createLumenPromptComposerController = (root) => {
+    const form = root.matches('form') ? root : root.querySelector('form');
+    const input = root.querySelector('[data-ui-prompt-input]');
+    const submit = root.querySelector('[data-ui-prompt-send]');
+    const stop = root.querySelector('[data-ui-prompt-stop]');
+    const view = root.ownerDocument.defaultView;
+    if (!form || !input || !submit || !view)
+        return { destroy: () => undefined, sync: () => undefined };
+    const sync = () => {
+        const pending = root.dataset.pending === 'true';
+        const disabled = root.dataset.disabled === 'true';
+        input.disabled = disabled;
+        const limit = input.maxLength > 0 ? input.maxLength : 4000;
+        submit.disabled = disabled || pending || !canSubmitLumenPrompt(input.value, limit);
+        if (stop) {
+            stop.hidden = !pending;
+            stop.disabled = disabled;
+        }
+        form.setAttribute('aria-busy', String(pending));
+    };
+    const send = (event) => {
+        sync();
+        if (submit.disabled) {
+            event.preventDefault();
+            return;
+        }
+        const detail = { text: input.value.trim() };
+        const accepted = root.dispatchEvent(new view.CustomEvent('ui:prompt-submit', { bubbles: true, cancelable: true, detail }));
+        if (!accepted || !form.hasAttribute('action'))
+            event.preventDefault();
+    };
+    const keydown = (event) => {
+        if (!isPlainSubmitKey(event))
+            return;
+        if (root.dataset.submitOnEnter !== 'true')
+            return;
+        event.preventDefault();
+        sync();
+        if (!submit.disabled && form instanceof view.HTMLFormElement)
+            form.requestSubmit(submit);
+    };
+    const stopRequest = () => {
+        if (root.dataset.pending !== 'true' || root.dataset.disabled === 'true')
+            return;
+        root.dispatchEvent(new view.CustomEvent('ui:prompt-stop', { bubbles: true }));
+    };
+    input.addEventListener('input', sync);
+    let resetTimer;
+    const reset = (event) => {
+        if (resetTimer !== undefined)
+            view.clearTimeout(resetTimer);
+        resetTimer = view.setTimeout(() => {
+            resetTimer = undefined;
+            if (!event.defaultPrevented)
+                sync();
+        });
+    };
+    input.addEventListener('keydown', keydown);
+    form.addEventListener('submit', send);
+    form.addEventListener('reset', reset);
+    stop?.addEventListener('click', stopRequest);
+    const observer = new view.MutationObserver(sync);
+    observer.observe(root, { attributeFilter: ['data-pending', 'data-disabled'], attributes: true });
+    sync();
+    return {
+        destroy: () => {
+            observer.disconnect();
+            input.removeEventListener('input', sync);
+            input.removeEventListener('keydown', keydown);
+            form.removeEventListener('submit', send);
+            form.removeEventListener('reset', reset);
+            if (resetTimer !== undefined)
+                view.clearTimeout(resetTimer);
+            stop?.removeEventListener('click', stopRequest);
+        },
+        sync
+    };
+};
+/** This event requests a decision; the application must still authorize the actual operation. */
+export const bindLumenApprovalCard = (root) => {
+    const view = root.ownerDocument.defaultView;
+    if (!view)
+        return () => undefined;
+    const sync = () => {
+        const disabled = root.dataset.disabled === 'true' || root.dataset.status !== 'pending' || !root.dataset.requestId;
+        for (const button of root.querySelectorAll('button[data-ui-approval-response]')) {
+            if (button.closest('[data-ui-approval-card]') === root)
+                button.disabled = disabled;
+        }
+    };
+    const observer = new view.MutationObserver(sync);
+    observer.observe(root, { attributeFilter: ['data-disabled', 'data-status', 'data-request-id'], attributes: true });
+    sync();
+    const click = (event) => {
+        if (!(event.target instanceof view.Element) || event.defaultPrevented || root.dataset.status !== 'pending')
+            return;
+        const button = event.target.closest('button[data-ui-approval-response]');
+        if (!button || button.disabled || button.closest('[data-ui-approval-card]') !== root)
+            return;
+        const requestId = root.dataset.requestId;
+        const response = button.dataset.uiApprovalResponse;
+        if (!requestId || (response !== 'approve' && response !== 'reject'))
+            return;
+        const detail = { requestId, response };
+        root.dispatchEvent(new view.CustomEvent('ui:approval-response', { bubbles: true, cancelable: true, detail }));
+    };
+    root.addEventListener('click', click);
+    return () => {
+        observer.disconnect();
+        root.removeEventListener('click', click);
+    };
+};

package/dist/amount-field.d.ts

@@ -0,0 +1,22 @@
+export interface LumenAmountOptions {
+    locale?: string;
+    fractionDigits?: number;
+    allowNegative?: boolean;
+}
+export interface LumenAmountChangeDetail {
+    /** Editable ASCII decimal draft; intermediate '-' and trailing decimal points are retained. */
+    draft: string;
+    /** Complete decimal string. Undefined for an empty or intermediate draft. */
+    value: string | undefined;
+}
+export declare const getLumenAmountValue: (draft: string) => string | undefined;
+export declare const formatLumenAmountDraft: (draft: string, options?: LumenAmountOptions) => string;
+export declare const parseLumenAmountDraft: (source: string, options?: LumenAmountOptions, strictGrouping?: boolean) => string | undefined;
+export interface LumenAmountFieldController {
+    destroy: () => void;
+    /** Rebind reset handling after moving the existing control to another document or shadow root. */
+    refresh: () => void;
+    setValue: (draft: string) => void;
+}
+export declare const createLumenAmountFieldController: (root: HTMLElement, onChange?: (detail: LumenAmountChangeDetail) => void) => LumenAmountFieldController;
+//# sourceMappingURL=amount-field.d.ts.map

package/dist/amount-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amount-field.d.ts","sourceRoot":"","sources":["../src/amount-field.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,+FAA+F;IAC/F,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B;AAqDD,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,MAAM,GAAG,SAI5D,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,EAAE,UAAS,kBAAuB,KAAG,MAcxF,CAAA;AAgDD,eAAO,MAAM,qBAAqB,GAChC,QAAQ,MAAM,EAAE,UAAS,kBAAuB,EAAE,wBAAqB,KACtE,MAAM,GAAG,SAYX,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,kGAAkG;IAClG,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC;AAeD,eAAO,MAAM,gCAAgC,GAC3C,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,KACtE,0BAsIF,CAAA"}

package/dist/amount-field.js

@@ -0,0 +1,207 @@
+const amountLimit = 1024;
+const validateFractionDigits = (digits) => {
+    if (!Number.isInteger(digits) || digits < 0 || digits > 20) {
+        throw new RangeError('Amount fractionDigits must be an integer from 0 to 20.');
+    }
+};
+const amountFormat = (options) => {
+    const fractionDigits = options.fractionDigits ?? 2;
+    let locale = options.locale ?? 'en-US';
+    validateFractionDigits(fractionDigits);
+    let formatter;
+    try {
+        formatter = new Intl.NumberFormat(locale, { useGrouping: true, maximumFractionDigits: 0 });
+    }
+    catch {
+        locale = 'en-US';
+        formatter = new Intl.NumberFormat(locale, { useGrouping: true, maximumFractionDigits: 0 });
+    }
+    const decimal = new Intl.NumberFormat(locale).formatToParts(1.1).find(part => part.type === 'decimal')?.value ?? '.';
+    const group = formatter.formatToParts(1000000).find(part => part.type === 'group')?.value;
+    const minus = formatter.formatToParts(-1).find(part => part.type === 'minusSign')?.value ?? '-';
+    const digitFormatter = new Intl.NumberFormat(locale, { useGrouping: false });
+    const digits = Array.from({ length: 10 }, (_, digit) => digitFormatter.format(digit));
+    return { formatter, decimal, group, minus, digits, fractionDigits };
+};
+const validDraft = (draft, options) => {
+    if (draft.length > amountLimit)
+        return false;
+    const { fractionDigits } = amountFormat(options);
+    const negative = draft.startsWith('-');
+    if (negative && !options.allowNegative)
+        return false;
+    const unsigned = negative ? draft.slice(1) : draft;
+    const pieces = unsigned.split('.');
+    if (pieces.length > 2 || (pieces.length === 2 && fractionDigits === 0))
+        return false;
+    const fraction = pieces[1] ?? '';
+    return pieces.every(piece => /^[0-9]*$/u.test(piece)) && fraction.length <= fractionDigits;
+};
+export const getLumenAmountValue = (draft) => {
+    if (!/^-?[0-9]+(?:\.[0-9]+)?$/u.test(draft) || draft.length > amountLimit)
+        return undefined;
+    return draft;
+};
+export const formatLumenAmountDraft = (draft, options = {}) => {
+    if (!validDraft(draft, options))
+        throw new RangeError('Amount value must be an ASCII decimal draft within the configured precision.');
+    if (draft === '')
+        return '';
+    const { formatter, decimal, minus, digits } = amountFormat(options);
+    const negative = draft.startsWith('-');
+    const unsigned = negative ? draft.slice(1) : draft;
+    const [integer = '', fraction] = unsigned.split('.');
+    const formattedInteger = integer ? formatter.format(BigInt(integer)) : '';
+    const localizedFraction = Array.from(fraction ?? '', digit => digits[Number(digit)] ?? digit).join('');
+    // Use an unsigned formatter so intermediate negative drafts never acquire a rounded sign.
+    return `${negative ? minus : ''}${formattedInteger}${fraction !== undefined ? decimal + localizedFraction : ''}`;
+};
+/** Strict grouping for paste; ordinary editing can temporarily disturb existing group separators. */
+const normalizeLeadingDecimal = (draft) => {
+    if (draft.startsWith('.'))
+        return `0${draft}`;
+    return draft.startsWith('-.') ? `-0${draft.slice(1)}` : draft;
+};
+const translateAmountCharacters = (source, options) => {
+    const { decimal, group, minus, digits } = amountFormat(options);
+    const characters = new Map(digits.map((digit, index) => [digit, String(index)]));
+    for (let index = 0; index < 10; index += 1)
+        characters.set(String(index), String(index));
+    characters.set(decimal, '.');
+    characters.set(minus, '-');
+    characters.set('-', '-');
+    if (group)
+        characters.set(group, '');
+    for (const mark of ['\u061c', '\u200e', '\u200f'])
+        characters.set(mark, '');
+    let draft = '';
+    for (const character of source.trim()) {
+        const translated = characters.get(character);
+        if (translated === undefined)
+            return undefined;
+        draft += translated;
+    }
+    return draft;
+};
+const validGrouping = (source, draft, options) => {
+    const { decimal, group } = amountFormat(options);
+    if (!group || !source.includes(group))
+        return true;
+    const [integer, fraction = ''] = source.trim().split(decimal);
+    return !fraction.includes(group) && integer === formatLumenAmountDraft(draft, options).split(decimal)[0];
+};
+export const parseLumenAmountDraft = (source, options = {}, strictGrouping = true) => {
+    if (source.length > amountLimit)
+        return undefined;
+    const translated = translateAmountCharacters(source, options);
+    if (translated === undefined || !validDraft(translated, options))
+        return undefined;
+    const draft = normalizeLeadingDecimal(translated);
+    if (strictGrouping && !validGrouping(source, draft, options))
+        return undefined;
+    return draft;
+};
+const placeAmountCaret = (input, group, logical) => {
+    let caret = 0;
+    let count = 0;
+    while (caret < input.value.length && count < logical) {
+        if (input.value[caret] !== group)
+            count += 1;
+        caret += 1;
+    }
+    input.setSelectionRange(caret, caret);
+};
+export const createLumenAmountFieldController = (root, onChange) => {
+    const input = root.querySelector('[data-ui-amount-input]');
+    const submission = root.querySelector('[data-ui-amount-value]');
+    if (!input || !submission)
+        throw new Error('AmountField requires visible and submission inputs.');
+    const options = {
+        locale: root.getAttribute('locale') ?? 'en-US',
+        fractionDigits: Number(root.getAttribute('fraction-digits') ?? 2),
+        allowNegative: root.hasAttribute('allow-negative')
+    };
+    const initial = root.getAttribute('default-value') ?? root.getAttribute('value') ?? '';
+    let draft = root.getAttribute('value') ?? initial;
+    let composing = false;
+    let destroyed = false;
+    let resetTimer;
+    const sync = () => {
+        input.value = formatLumenAmountDraft(draft, options);
+        submission.value = getLumenAmountValue(draft) ?? '';
+        input.setCustomValidity(draft !== '' && getLumenAmountValue(draft) === undefined ? root.getAttribute('invalid-message') ?? 'Enter a complete amount.' : '');
+    };
+    const group = amountFormat(options).group;
+    const logicalCount = (text) => Array.from(text).filter(character => character !== group).length;
+    const emitChange = () => {
+        const detail = { draft, value: getLumenAmountValue(draft) };
+        const EventType = root.ownerDocument.defaultView?.CustomEvent;
+        if (EventType)
+            root.dispatchEvent(new EventType('ui:amount-change', { bubbles: true, detail }));
+        onChange?.(detail);
+    };
+    const update = (event) => {
+        if (composing || input.matches(':disabled') || input.readOnly)
+            return;
+        const logical = logicalCount(input.value.slice(0, input.selectionStart ?? input.value.length));
+        const parsed = parseLumenAmountDraft(input.value, options, 'inputType' in event && event.inputType === 'insertFromPaste');
+        if (parsed === undefined) {
+            sync();
+            input.setCustomValidity(root.getAttribute('invalid-message') ?? 'Enter a valid amount using the displayed locale and precision.');
+            return;
+        }
+        draft = parsed;
+        sync();
+        placeAmountCaret(input, group, logical);
+        emitChange();
+    };
+    const startComposition = () => {
+        composing = true;
+    };
+    const endComposition = (event) => {
+        composing = false;
+        update(event);
+    };
+    const reset = (event) => {
+        if (event.target !== input.form)
+            return;
+        clearTimeout(resetTimer);
+        resetTimer = setTimeout(() => {
+            if (destroyed || event.defaultPrevented || event.target !== input.form)
+                return;
+            draft = root.getAttribute('default-value') ?? initial;
+            sync();
+            onChange?.({ draft, value: getLumenAmountValue(draft) });
+        });
+    };
+    sync();
+    input.addEventListener('input', update);
+    input.addEventListener('compositionstart', startComposition);
+    input.addEventListener('compositionend', endComposition);
+    let eventRoot;
+    const refresh = () => {
+        const current = input.getRootNode();
+        if (destroyed || current === eventRoot)
+            return;
+        clearTimeout(resetTimer);
+        eventRoot?.removeEventListener('reset', reset, { capture: true });
+        eventRoot = current;
+        eventRoot.addEventListener('reset', reset, { capture: true });
+    };
+    refresh();
+    return {
+        refresh,
+        setValue: value => {
+            draft = value;
+            sync();
+        },
+        destroy: () => {
+            destroyed = true;
+            clearTimeout(resetTimer);
+            input.removeEventListener('input', update);
+            input.removeEventListener('compositionstart', startComposition);
+            input.removeEventListener('compositionend', endComposition);
+            eventRoot?.removeEventListener('reset', reset, { capture: true });
+        }
+    };
+};

package/dist/attachments.d.ts

@@ -0,0 +1,15 @@
+export type LumenAttachmentPreviewState = 'error' | 'loading' | 'ready' | 'unavailable';
+export interface LumenAttachmentPreviewLabels {
+    error: string;
+    loading: string;
+    unavailable: string;
+}
+export declare const lumenAttachmentPreviewLabels: Readonly<LumenAttachmentPreviewLabels>;
+export declare const resolveLumenAttachmentPreviewState: (src?: unknown, contentType?: unknown, state?: LumenAttachmentPreviewState, failed?: boolean) => LumenAttachmentPreviewState;
+export interface LumenAttachmentPreviewController {
+    destroy: () => void;
+    refresh: () => void;
+}
+/** Enhances a browser-owned image; never fetches a file or embeds a document. */
+export declare const createLumenAttachmentPreviewController: (root: HTMLElement) => LumenAttachmentPreviewController;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,CAAA;AAEvF,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,4BAA4B,CAI/E,CAAA;AAQD,eAAO,MAAM,kCAAkC,GAC7C,MAAM,OAAO,EACb,cAAc,OAAO,EACrB,QAAQ,2BAA2B,EACnC,gBAAc,KACb,2BAMF,CAAA;AAID,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,iFAAiF;AACjF,eAAO,MAAM,sCAAsC,GAAI,MAAM,WAAW,KAAG,gCAqI1E,CAAA"}

package/dist/attachments.js

@@ -0,0 +1,123 @@
+export const lumenAttachmentPreviewLabels = {
+    error: 'Could not load the preview.',
+    loading: 'Loading preview…',
+    unavailable: 'A preview is not available for this file.'
+};
+const isImageContentType = (contentType) => {
+    if (contentType === undefined || contentType === null || contentType === '')
+        return true;
+    return typeof contentType === 'string' && contentType.trim().toLowerCase().startsWith('image/');
+};
+export const resolveLumenAttachmentPreviewState = (src, contentType, state, failed = false) => {
+    if (state === 'loading' || state === 'error' || state === 'unavailable')
+        return state;
+    if (typeof src !== 'string' || !src.trim() || !isImageContentType(contentType))
+        return 'unavailable';
+    return failed ? 'error' : 'ready';
+};
+const requestedState = (value) => value === 'error' || value === 'loading' || value === 'ready' || value === 'unavailable' ? value : undefined;
+/** Enhances a browser-owned image; never fetches a file or embeds a document. */
+export const createLumenAttachmentPreviewController = (root) => {
+    const owned = (selector) => Array.from(root.querySelectorAll(selector)).find(element => element.closest('[data-ui-attachment-preview]') === root);
+    const currentImage = () => {
+        const candidate = owned('[data-ui-attachment-preview-image]');
+        const isImage = (element) => element?.namespaceURI === 'http://www.w3.org/1999/xhtml' && element.localName === 'img';
+        return isImage(candidate) ? candidate : undefined;
+    };
+    let image = currentImage();
+    const abort = new AbortController();
+    const cachedFailure = (candidate) => Boolean(candidate?.getAttribute('src') && candidate.complete && candidate.naturalWidth === 0);
+    const attribute = (name) => root.getAttribute(name) ?? root.getAttribute(`data-ui-attachment-preview-${name}`);
+    let failed = cachedFailure(image);
+    let source = image?.getAttribute('src') ?? '';
+    let retryKey = attribute('retry-key') ?? '';
+    let previous;
+    let destroyed = false;
+    const reloadImage = () => {
+        if (image && source)
+            image.setAttribute('src', source);
+    };
+    const updateSource = () => {
+        const nextImage = currentImage();
+        if (image !== nextImage) {
+            image = nextImage;
+            failed = cachedFailure(image);
+        }
+        const nextSource = image?.getAttribute('src') ?? '';
+        const nextRetryKey = attribute('retry-key') ?? '';
+        if (source === nextSource && retryKey === nextRetryKey)
+            return;
+        const retry = retryKey !== nextRetryKey;
+        source = nextSource;
+        retryKey = nextRetryKey;
+        failed = !retry && cachedFailure(image);
+        if (retry)
+            reloadImage();
+    };
+    const renderState = (state) => {
+        const media = owned('[data-slot="attachment-preview-media"]');
+        const message = owned('[data-ui-attachment-preview-message]');
+        root.dataset.state = state;
+        root.setAttribute('aria-busy', String(state === 'loading'));
+        if (media)
+            media.hidden = state !== 'ready';
+        if (!message)
+            return;
+        message.hidden = state === 'ready';
+        if (state !== 'ready')
+            message.textContent = attribute(`${state}-label`) ?? lumenAttachmentPreviewLabels[state];
+    };
+    const refresh = () => {
+        if (destroyed)
+            return;
+        updateSource();
+        const state = resolveLumenAttachmentPreviewState(source, attribute('content-type'), requestedState(attribute('state')), failed);
+        renderState(state);
+        if (previous !== undefined && previous !== state) {
+            const EventConstructor = root.ownerDocument.defaultView?.CustomEvent ?? CustomEvent;
+            root.dispatchEvent(new EventConstructor('ui:attachment-preview-change', { bubbles: true, detail: { state } }));
+        }
+        previous = state;
+    };
+    root.addEventListener('error', event => {
+        if (!root.isConnected || event.target !== currentImage())
+            return;
+        failed = true;
+        refresh();
+    }, { capture: true, signal: abort.signal });
+    root.addEventListener('load', event => {
+        if (!root.isConnected || event.target !== currentImage())
+            return;
+        failed = false;
+        refresh();
+    }, { capture: true, signal: abort.signal });
+    const observer = new MutationObserver(records => {
+        if (records.some(record => record.type === 'attributes' || Array.from(record.addedNodes).some(node => node.nodeType === 1) || Array.from(record.removedNodes).some(node => node.nodeType === 1)))
+            refresh();
+    });
+    observer.observe(root, { subtree: true,
+        childList: true,
+        attributes: true,
+        attributeFilter: [
+            'src',
+            'state',
+            'content-type',
+            'retry-key',
+            'error-label',
+            'loading-label',
+            'unavailable-label',
+            'data-ui-attachment-preview-state',
+            'data-ui-attachment-preview-content-type',
+            'data-ui-attachment-preview-retry-key',
+            'data-ui-attachment-preview-error-label',
+            'data-ui-attachment-preview-loading-label',
+            'data-ui-attachment-preview-unavailable-label'
+        ] });
+    refresh();
+    return { refresh,
+        destroy: () => {
+            destroyed = true;
+            abort.abort();
+            observer.disconnect();
+        } };
+};

package/dist/bullet-chart.d.ts

@@ -0,0 +1,33 @@
+import { type LumenChartDomain, type LumenChartTone } from './charts.js';
+export interface LumenBulletRange {
+    end: number;
+    label: string;
+    tone?: LumenChartTone;
+}
+export interface LumenBulletOptions {
+    domain?: LumenChartDomain | undefined;
+    ranges?: readonly LumenBulletRange[] | undefined;
+}
+/** A zero-based actual-versus-target comparison with optional qualitative ranges. */
+export declare const createLumenBulletGeometry: (value: number | null, target: number, options?: LumenBulletOptions) => {
+    domain: LumenChartDomain;
+    ranges: {
+        start: number;
+        startRatio: number;
+        endRatio: number;
+        end: number;
+        label: string;
+        tone?: LumenChartTone;
+    }[];
+    target: number;
+    targetRatio: number;
+    ticks: {
+        value: number;
+        position: number;
+    }[];
+    valid: boolean;
+    value: number | null;
+    valueStartRatio: number;
+    valueWidthRatio: number;
+};
+//# sourceMappingURL=bullet-chart.d.ts.map

package/dist/bullet-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullet-chart.d.ts","sourceRoot":"","sources":["../src/bullet-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAyC,MAAM,aAAa,CAAA;AAE/G,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,cAAc,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAA;IACrC,MAAM,CAAC,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,CAAA;CACjD;AAoED,qFAAqF;AACrF,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,GAAG,IAAI,EAAE,QAAQ,MAAM,EAAE,UAAS,kBAAuB;;;;;;aA7EzG,MAAM;eACJ,MAAM;eACN,cAAc;;;;;;;;;;;;CAyGtB,CAAA"}

package/dist/bullet-chart.js

@@ -0,0 +1,80 @@
+import { lumenChartTones, scaleLumenChartValue } from './charts.js';
+const validBulletTone = (value) => value === undefined || lumenChartTones.some(tone => tone === value);
+const validBulletRange = (range) => {
+    if (typeof range !== 'object' || range === null)
+        return false;
+    if (!('end' in range) || !('label' in range))
+        return false;
+    return Number.isFinite(range.end) && typeof range.label === 'string' &&
+        validBulletTone('tone' in range ? range.tone : undefined);
+};
+const validatedBulletRanges = (input) => {
+    if (!Array.isArray(input))
+        return null;
+    const rows = Array.from(input);
+    return rows.every(validBulletRange) ? rows : null;
+};
+const automaticBulletDomain = (values) => {
+    let minimum = 0;
+    let maximum = 0;
+    for (const number of values) {
+        if (!Number.isFinite(number))
+            continue;
+        minimum = Math.min(minimum, number);
+        maximum = Math.max(maximum, number);
+    }
+    return { min: minimum, max: minimum === maximum ? minimum + 1 : maximum };
+};
+const validBulletDomain = (domain) => {
+    const finite = Number.isFinite(domain.min) && Number.isFinite(domain.max);
+    return finite && domain.min < domain.max && domain.min <= 0 && domain.max >= 0;
+};
+const orderedBulletRanges = (ranges, domain) => {
+    let previousEnd = domain.min;
+    return ranges.every(range => {
+        const valid = range.label.trim().length > 0 && range.end > previousEnd;
+        previousEnd = range.end;
+        return valid;
+    });
+};
+const resolveBulletModel = (value, target, options) => {
+    const { ranges: configuredRanges = [] } = options;
+    const inputRanges = validatedBulletRanges(configuredRanges);
+    const finiteRanges = inputRanges !== null;
+    const ranges = [...inputRanges ?? []].sort((left, right) => left.end - right.end);
+    const values = [0, target, ...ranges.map(range => range.end), ...value === null ? [] : [value]];
+    const requested = options.domain ?? automaticBulletDomain(values);
+    const domain = validBulletDomain(requested) ? requested : { min: 0, max: 1 };
+    const withinDomain = values.every(number => Number.isFinite(number) && number >= domain.min && number <= domain.max);
+    const valid = finiteRanges && validBulletDomain(requested) && withinDomain && orderedBulletRanges(ranges, domain);
+    return { domain, ranges, valid };
+};
+/** A zero-based actual-versus-target comparison with optional qualitative ranges. */
+export const createLumenBulletGeometry = (value, target, options = {}) => {
+    const { domain, ranges, valid } = resolveBulletModel(value, target, options);
+    const position = (number) => scaleLumenChartValue(number, domain, 0, 1);
+    const zero = position(0);
+    const actual = valid && value !== null ? position(value) : zero;
+    let start = domain.min;
+    return {
+        domain,
+        ranges: valid ?
+            ranges.map(range => {
+                const segment = { ...range, start, startRatio: position(start), endRatio: position(range.end) };
+                start = range.end;
+                return segment;
+            }) :
+            [],
+        target,
+        targetRatio: valid ? position(target) : zero,
+        ticks: valid ?
+            [domain.min, domain.min / 2 + domain.max / 2, domain.max].map(tick => ({
+                value: tick, position: position(tick)
+            })) :
+            [],
+        valid,
+        value,
+        valueStartRatio: Math.min(zero, actual),
+        valueWidthRatio: Math.abs(actual - zero)
+    };
+};