markstream-svelte 0.0.1-beta.1

package/dist/workers/katexCdnWorker.js

@@ -0,0 +1,193 @@
+function stringifyForWorker(value) {
+    return JSON.stringify(value);
+}
+export function buildKaTeXCDNWorkerSource(options) {
+    var _a;
+    const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : 'classic';
+    const renderOptions = {
+        throwOnError: true,
+        displayMode: true,
+        output: 'html',
+        strict: 'ignore',
+        ...(options.renderOptions || {}),
+    };
+    const renderOptionsLiteral = stringifyForWorker(renderOptions);
+    const katexUrlLiteral = stringifyForWorker(options.katexUrl);
+    const mhchemUrlLiteral = options.mhchemUrl ? stringifyForWorker(options.mhchemUrl) : '""';
+    if (mode === 'module') {
+        return `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+let loadPromise = null
+
+function normalizeKaTeX(mod) {
+  const resolved = mod && mod.default ? mod.default : mod
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+async function loadKaTeX() {
+  if (katex || katexLoadError)
+    return
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const mod = await import(${katexUrlLiteral})
+        katex = normalizeKaTeX(mod) || null
+        const mhchemUrl = ${mhchemUrlLiteral}
+        if (mhchemUrl) {
+          try {
+            await import(mhchemUrl)
+          }
+          catch (e) {
+            if (DEBUG)
+              console.warn('[markstream-svelte:katex-cdn-worker] failed to load mhchem', e)
+          }
+        }
+      }
+      catch (e) {
+        katexLoadError = e
+      }
+    })()
+  }
+  await loadPromise
+}
+
+globalThis.addEventListener('message', async (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  await loadKaTeX()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${renderOptionsLiteral}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart();
+    }
+    return `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+
+function normalizeKaTeX(val) {
+  const resolved = val && val.default ? val.default : val
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+function loadKaTeXClassic() {
+  if (katex || katexLoadError)
+    return
+  try {
+    importScripts(${katexUrlLiteral})
+    const mhchemUrl = ${mhchemUrlLiteral}
+    if (mhchemUrl) {
+      try {
+        importScripts(mhchemUrl)
+      }
+      catch (e) {
+        if (DEBUG)
+          console.warn('[markstream-svelte:katex-cdn-worker] failed to load mhchem', e)
+      }
+    }
+    katex = normalizeKaTeX(globalThis.katex)
+  }
+  catch (e) {
+    katexLoadError = e
+  }
+}
+
+loadKaTeXClassic()
+
+globalThis.addEventListener('message', (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  if (!katex && !katexLoadError)
+    loadKaTeXClassic()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${renderOptionsLiteral}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart();
+}
+export function createKaTeXWorkerFromCDN(options) {
+    var _a, _b;
+    const source = buildKaTeXCDNWorkerSource(options);
+    if (typeof Worker === 'undefined' || typeof URL === 'undefined' || typeof Blob === 'undefined') {
+        return {
+            worker: null,
+            dispose: () => { },
+            source,
+        };
+    }
+    const blob = new Blob([source], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    let revoked = false;
+    const dispose = () => {
+        if (revoked)
+            return;
+        revoked = true;
+        try {
+            URL.revokeObjectURL(url);
+        }
+        catch {
+            // Ignore revoke failures.
+        }
+    };
+    const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : 'classic';
+    const workerOptions = mode === 'module'
+        ? { ...((_b = options.workerOptions) !== null && _b !== void 0 ? _b : {}), type: 'module' }
+        : options.workerOptions;
+    const worker = new Worker(url, workerOptions);
+    if (options.debug) {
+        try {
+            worker.postMessage({ type: 'init', debug: true });
+        }
+        catch {
+            // Ignore init messaging failures.
+        }
+    }
+    return { worker, dispose, source };
+}

package/dist/workers/katexRenderer.worker.d.ts

@@ -0,0 +1,2 @@
+import 'katex/dist/contrib/mhchem';
+//# sourceMappingURL=katexRenderer.worker.d.ts.map

package/dist/workers/katexRenderer.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"katexRenderer.worker.d.ts","sourceRoot":"","sources":["../../src/workers/katexRenderer.worker.ts"],"names":[],"mappings":"AACA,OAAO,2BAA2B,CAAA"}

package/dist/workers/katexRenderer.worker.js

@@ -0,0 +1,55 @@
+import katex from 'katex';
+import 'katex/dist/contrib/mhchem';
+let debugWorker = false;
+globalThis.addEventListener('message', (event) => {
+    var _a, _b, _c, _d;
+    const data = event.data || {};
+    if (data.type === 'init') {
+        debugWorker = !!data.debug;
+        return;
+    }
+    const id = (_a = data.id) !== null && _a !== void 0 ? _a : '';
+    const content = (_b = data.content) !== null && _b !== void 0 ? _b : '';
+    const displayMode = (_c = data.displayMode) !== null && _c !== void 0 ? _c : true;
+    try {
+        if (debugWorker)
+            console.debug('[markstream-svelte:katexRenderer.worker] render start', { id, displayMode, content });
+        const html = katex.renderToString(content, {
+            throwOnError: true,
+            displayMode,
+            output: 'html',
+            strict: 'ignore',
+        });
+        const result = {
+            id,
+            html,
+            content,
+            displayMode,
+        };
+        globalThis.postMessage(result);
+    }
+    catch (error) {
+        const result = {
+            id,
+            error: String((_d = error === null || error === void 0 ? void 0 : error.message) !== null && _d !== void 0 ? _d : error),
+            content,
+            displayMode,
+        };
+        globalThis.postMessage(result);
+    }
+});
+globalThis.addEventListener('error', (event) => {
+    var _a;
+    try {
+        ;
+        globalThis.postMessage({
+            id: '__worker_uncaught__',
+            error: String((_a = event.message) !== null && _a !== void 0 ? _a : event.error),
+            content: '',
+            displayMode: true,
+        });
+    }
+    catch {
+        // Ignore postMessage failures while surfacing uncaught worker errors.
+    }
+});

package/dist/workers/katexWorkerClient.d.ts

@@ -0,0 +1,36 @@
+export declare const WORKER_BUSY_CODE = "WORKER_BUSY";
+export declare function setKaTeXWorker(nextWorker: Worker): void;
+export declare function clearKaTeXWorker(): void;
+export declare function setKaTeXWorkerDebug(enabled: boolean): void;
+export declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
+export declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
+export declare function getKaTeXWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+export declare function setKaTeXWorkerMaxConcurrency(value: number): void;
+export declare function isKaTeXWorkerBusy(): boolean;
+export declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
+export interface BackpressureOptions {
+    timeout?: number;
+    waitTimeout?: number;
+    backoffMs?: number;
+    maxRetries?: number;
+    signal?: AbortSignal;
+}
+declare const defaultBackpressure: {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+export declare function setKaTeXBackpressureDefaults(options: Partial<typeof defaultBackpressure>): void;
+export declare function getKaTeXBackpressureDefaults(): {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+export declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, options?: BackpressureOptions): Promise<string>;
+export {};
+//# sourceMappingURL=katexWorkerClient.d.ts.map

package/dist/workers/katexWorkerClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"katexWorkerClient.d.ts","sourceRoot":"","sources":["../../src/workers/katexWorkerClient.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,gBAAgB,CAAA;AA4C7C,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,QAmChD;AAED,wBAAgB,gBAAgB,SAK/B;AAYD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QAInD;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,UAAO,EAAE,OAAO,SAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CA8EpI;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,SAAO,EAAE,IAAI,EAAE,MAAM,QAE9E;AAED,wBAAgB,kBAAkB;;;EAKjC;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,QAGzD;AAED,wBAAgB,iBAAiB,YAEhC;AAED,wBAAgB,sBAAsB,CAAC,OAAO,SAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD1F;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,QAAA,MAAM,mBAAmB;;;;;CAKxB,CAAA;AAGD,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,mBAAmB,CAAC,QASxF;AAED,wBAAgB,4BAA4B;;;;;EAE3C;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,MAAM,EACf,WAAW,UAAO,EAClB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,MAAM,CAAC,CAqCjB"}

package/dist/workers/katexWorkerClient.js

@@ -0,0 +1,270 @@
+import { isKatexEnabled } from '../optional/katex';
+import { normalizeKaTeXRenderInput } from '../utils/normalizeKaTeXRenderInput';
+export const WORKER_BUSY_CODE = 'WORKER_BUSY';
+let worker = null;
+let workerInitError = null;
+let debugKatexWorker = false;
+const pending = new Map();
+const cache = new Map();
+const cacheMax = 200;
+const drainWaiters = new Set();
+let maxConcurrency = 5;
+function notifyDrainIfBelowCap() {
+    if (pending.size >= maxConcurrency || drainWaiters.size === 0)
+        return;
+    const currentWaiters = Array.from(drainWaiters);
+    drainWaiters.clear();
+    for (const waiter of currentWaiters) {
+        try {
+            waiter();
+        }
+        catch {
+            // Ignore waiter failures.
+        }
+    }
+}
+function rememberCache(content, displayMode, html) {
+    cache.set(`${displayMode ? 'd' : 'i'}:${content}`, html);
+    if (cache.size > cacheMax) {
+        const firstKey = cache.keys().next().value;
+        if (firstKey)
+            cache.delete(firstKey);
+    }
+}
+export function setKaTeXWorker(nextWorker) {
+    worker = nextWorker;
+    workerInitError = null;
+    worker.onmessage = (event) => {
+        const { id, html, error, content, displayMode } = event.data || {};
+        const active = pending.get(id);
+        if (!active)
+            return;
+        pending.delete(id);
+        clearTimeout(active.timeoutId);
+        notifyDrainIfBelowCap();
+        if (error) {
+            active.reject(new Error(error));
+            return;
+        }
+        if (content)
+            rememberCache(String(content), Boolean(displayMode), String(html || ''));
+        active.resolve(String(html || ''));
+    };
+    worker.onerror = (event) => {
+        for (const [, active] of pending.entries()) {
+            clearTimeout(active.timeoutId);
+            active.reject(new Error(`Worker error: ${event.message}`));
+        }
+        pending.clear();
+        notifyDrainIfBelowCap();
+    };
+    if (debugKatexWorker)
+        worker.postMessage({ type: 'init', debug: true });
+}
+export function clearKaTeXWorker() {
+    var _a;
+    if (worker)
+        (_a = worker.terminate) === null || _a === void 0 ? void 0 : _a.call(worker);
+    worker = null;
+    workerInitError = null;
+}
+function ensureWorker() {
+    if (worker)
+        return worker;
+    workerInitError = new Error('[markstream-svelte:katexWorkerClient] No worker instance set. Please inject a Worker via setKaTeXWorker().');
+    workerInitError.name = 'WorkerInitError';
+    workerInitError.code = 'WORKER_INIT_ERROR';
+    return null;
+}
+export function setKaTeXWorkerDebug(enabled) {
+    debugKatexWorker = !!enabled;
+    if (worker)
+        worker.postMessage({ type: 'init', debug: debugKatexWorker });
+}
+export async function renderKaTeXInWorker(content, displayMode = true, timeout = 2000, signal) {
+    const normalizedContent = normalizeKaTeXRenderInput(content);
+    if (!isKatexEnabled()) {
+        const error = new Error('KaTeX rendering disabled');
+        error.name = 'KaTeXDisabled';
+        error.code = 'KATEX_DISABLED';
+        return Promise.reject(error);
+    }
+    if (workerInitError)
+        return Promise.reject(workerInitError);
+    const cacheKey = `${displayMode ? 'd' : 'i'}:${normalizedContent}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const activeWorker = ensureWorker();
+    if (!activeWorker)
+        return Promise.reject(workerInitError);
+    if (pending.size >= maxConcurrency) {
+        const error = new Error('Worker busy');
+        error.name = 'WorkerBusy';
+        error.code = WORKER_BUSY_CODE;
+        error.busy = true;
+        error.inFlight = pending.size;
+        error.max = maxConcurrency;
+        return Promise.reject(error);
+    }
+    return new Promise((resolve, reject) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            reject(error);
+            return;
+        }
+        const id = Math.random().toString(36).slice(2);
+        const timeoutId = globalThis.setTimeout(() => {
+            pending.delete(id);
+            notifyDrainIfBelowCap();
+            const error = new Error('Worker render timed out');
+            error.name = 'WorkerTimeout';
+            error.code = 'WORKER_TIMEOUT';
+            reject(error);
+        }, timeout);
+        const onAbort = () => {
+            globalThis.clearTimeout(timeoutId);
+            if (pending.delete(id))
+                notifyDrainIfBelowCap();
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            reject(error);
+        };
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+        pending.set(id, {
+            timeoutId,
+            resolve: (html) => {
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+                resolve(html);
+            },
+            reject: (error) => {
+                signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+                reject(error);
+            },
+        });
+        activeWorker.postMessage({
+            id,
+            type: 'render',
+            content: normalizedContent,
+            displayMode,
+        });
+    });
+}
+export function setKaTeXCache(content, displayMode = true, html) {
+    rememberCache(normalizeKaTeXRenderInput(content), displayMode, html);
+}
+export function getKaTeXWorkerLoad() {
+    return {
+        inFlight: pending.size,
+        max: maxConcurrency,
+    };
+}
+export function setKaTeXWorkerMaxConcurrency(value) {
+    if (Number.isFinite(value) && value > 0)
+        maxConcurrency = Math.floor(value);
+}
+export function isKaTeXWorkerBusy() {
+    return pending.size >= maxConcurrency;
+}
+export function waitForKaTeXWorkerSlot(timeout = 2000, signal) {
+    if (pending.size < maxConcurrency)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer = null;
+        const onDrain = () => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            drainWaiters.delete(onDrain);
+            resolve();
+        };
+        drainWaiters.add(onDrain);
+        timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            drainWaiters.delete(onDrain);
+            const error = new Error('Wait for worker slot timed out');
+            error.name = 'WorkerBusyTimeout';
+            error.code = 'WORKER_BUSY_TIMEOUT';
+            reject(error);
+        }, timeout);
+        queueMicrotask(() => notifyDrainIfBelowCap());
+        if (signal) {
+            const onAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                drainWaiters.delete(onDrain);
+                const error = new Error('Aborted');
+                error.name = 'AbortError';
+                reject(error);
+            };
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
+}
+const defaultBackpressure = {
+    timeout: 2000,
+    waitTimeout: 1500,
+    backoffMs: 30,
+    maxRetries: 1,
+};
+const maxBackpressureRetries = 8;
+export function setKaTeXBackpressureDefaults(options) {
+    if (options.timeout != null)
+        defaultBackpressure.timeout = Math.max(0, Math.floor(options.timeout));
+    if (options.waitTimeout != null)
+        defaultBackpressure.waitTimeout = Math.max(0, Math.floor(options.waitTimeout));
+    if (options.backoffMs != null)
+        defaultBackpressure.backoffMs = Math.max(0, Math.floor(options.backoffMs));
+    if (options.maxRetries != null)
+        defaultBackpressure.maxRetries = Math.max(0, Math.floor(options.maxRetries));
+}
+export function getKaTeXBackpressureDefaults() {
+    return { ...defaultBackpressure };
+}
+export async function renderKaTeXWithBackpressure(content, displayMode = true, options = {}) {
+    var _a, _b, _c, _d, _e;
+    if (!isKatexEnabled()) {
+        const error = new Error('KaTeX rendering disabled');
+        error.name = 'KaTeXDisabled';
+        error.code = 'KATEX_DISABLED';
+        throw error;
+    }
+    const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : defaultBackpressure.timeout;
+    const waitTimeout = (_b = options.waitTimeout) !== null && _b !== void 0 ? _b : defaultBackpressure.waitTimeout;
+    const backoffMs = (_c = options.backoffMs) !== null && _c !== void 0 ? _c : defaultBackpressure.backoffMs;
+    const rawMaxRetries = (_d = options.maxRetries) !== null && _d !== void 0 ? _d : defaultBackpressure.maxRetries;
+    const maxRetries = Number.isFinite(rawMaxRetries)
+        ? Math.max(0, Math.min(Math.floor(rawMaxRetries), maxBackpressureRetries))
+        : defaultBackpressure.maxRetries;
+    let attempt = 0;
+    for (;;) {
+        if ((_e = options.signal) === null || _e === void 0 ? void 0 : _e.aborted) {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            throw error;
+        }
+        try {
+            return await renderKaTeXInWorker(content, displayMode, timeout, options.signal);
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.code) !== WORKER_BUSY_CODE || attempt >= maxRetries)
+                throw error;
+            attempt += 1;
+            await waitForKaTeXWorkerSlot(waitTimeout, options.signal).catch(() => { });
+            if (backoffMs > 0)
+                await new Promise(resolve => globalThis.setTimeout(resolve, backoffMs * attempt));
+        }
+    }
+}

package/dist/workers/mermaidCdnWorker.d.ts

@@ -0,0 +1,16 @@
+export type MermaidCDNWorkerMode = 'classic' | 'module';
+export interface MermaidCDNWorkerOptions {
+    mermaidUrl: string;
+    mode?: MermaidCDNWorkerMode;
+    debug?: boolean;
+    workerOptions?: WorkerOptions;
+    initializeOptions?: Record<string, any>;
+}
+export interface MermaidCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+export declare function buildMermaidCDNWorkerSource(options: MermaidCDNWorkerOptions): string;
+export declare function createMermaidWorkerFromCDN(options: MermaidCDNWorkerOptions): MermaidCDNWorkerHandle;
+//# sourceMappingURL=mermaidCdnWorker.d.ts.map

package/dist/workers/mermaidCdnWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaidCdnWorker.d.ts","sourceRoot":"","sources":["../../src/workers/mermaidCdnWorker.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,QAAQ,CAAA;AAEvD,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,oBAAoB,CAAA;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CACxC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf;AAMD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,uBAAuB,GAAG,MAAM,CAkMpF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CA2CnG"}