@yschimke/livery-a2ui 0.0.0-stage → 0.11.0

package/dist/livery-web/livery-livery-web.import-object.mjs

@@ -0,0 +1,370 @@
+
+import * as QGpzLWpvZGEvY29yZQ from '@js-joda/core';
+import * as d2FzbTpqcy1zdHJpbmc from './livery-livery-web.js-builtins.mjs';
+
+const wasmJsTag = WebAssembly.JSTag;
+const wasmTag = wasmJsTag ?? new WebAssembly.Tag({ parameters: ['externref'] });
+
+// Placed here to give access to it from externals (js_code)
+let wasmExports;
+
+if (typeof process !== 'undefined' && process.release.name === 'node') {
+    function doNotUseRequire() {
+        throw new Error("Do not use top-level require. Prefer to use JS import or define your own require instead. Read more: https://kotl.in/r9txlt")
+    }
+
+    var require = new Proxy((function() {}), {
+        apply(target, thisArg, argumentsList) {
+            if (globalThis.require != null) {
+                return globalThis.require.apply(thisArg, argumentsList);
+            } else {
+                doNotUseRequire();
+            }
+        },
+        get(target, prop, receiver) {
+            if (globalThis.require != null) {
+                return Reflect.get(globalThis.require, prop);
+            } else {
+                doNotUseRequire();
+            }
+        },
+    });
+}
+
+export function setWasmExports(exports) {
+    wasmExports = exports;
+}
+
+const _ref_QGpzLWpvZGEvY29yZQ_ = QGpzLWpvZGEvY29yZQ;
+
+const cachedJsObjects = new WeakMap();
+function getCachedJsObject(ref, ifNotCached) {
+    if (typeof ref !== 'object' && typeof ref !== 'function') return ifNotCached;
+    const cached = cachedJsObjects.get(ref);
+    if (cached !== void 0) return cached;
+    cachedJsObjects.set(ref, ifNotCached);
+    return ifNotCached;
+}
+
+const js_code = {
+    'kotlin.createJsError' : (message, cause) => new Error(message, { cause }),
+    'kotlin.wasm.internal.jsThrow' : wasmTag === wasmJsTag ? (e) => { throw e; } : () => {},
+    'kotlin.wasm.internal.getJsEmptyString' : () => '',
+    'kotlin.wasm.internal.externrefToBoolean' : (ref) => Boolean(ref),
+    'kotlin.wasm.internal.externrefToString' : (ref) => String(ref),
+    'kotlin.wasm.internal.externrefEquals' : (lhs, rhs) => lhs === rhs,
+    'kotlin.wasm.internal.externrefHashCode' : 
+    (() => {
+    const dataView = new DataView(new ArrayBuffer(8));
+    function numberHashCode(obj) {
+        if ((obj | 0) === obj) {
+            return obj | 0;
+        } else {
+            dataView.setFloat64(0, obj, true);
+            return (dataView.getInt32(0, true) * 31 | 0) + dataView.getInt32(4, true) | 0;
+        }
+    }
+
+    const hashCodes = new WeakMap();
+    function getObjectHashCode(obj) {
+        const res = hashCodes.get(obj);
+        if (res === undefined) {
+            const POW_2_32 = 4294967296;
+            const hash = (Math.random() * POW_2_32) | 0;
+            hashCodes.set(obj, hash);
+            return hash;
+        }
+        return res;
+    }
+
+    function getStringHashCode(str) {
+        var hash = 0;
+        for (var i = 0; i < str.length; i++) {
+            var code  = str.charCodeAt(i);
+            hash  = (hash * 31 + code) | 0;
+        }
+        return hash;
+    }
+
+    return (obj) => {
+        if (obj == null) {
+            return 0;
+        }
+        switch (typeof obj) {
+            case "object":
+            case "function":
+                return getObjectHashCode(obj);
+            case "number":
+                return numberHashCode(obj);
+            case "boolean":
+                return obj ? 1231 : 1237;
+            default:
+                return getStringHashCode(String(obj)); 
+        }
+    }
+    })(),
+    'kotlin.wasm.internal.isNullish' : (ref) => ref == null,
+    'kotlin.wasm.internal.intToExternref' : (x) => x,
+    'kotlin.wasm.internal.getJsTrue' : () => true,
+    'kotlin.wasm.internal.getJsFalse' : () => false,
+    'kotlin.wasm.internal.kotlinUIntToJsNumberUnsafe' : (x) => x >>> 0,
+    'kotlin.wasm.internal.kotlinULongToJsBigIntUnsafe' : (x) => x & 0xFFFFFFFFFFFFFFFFn,
+    'kotlin.wasm.internal.newJsArray' : () => [],
+    'kotlin.wasm.internal.jsArrayPush' : (array, element) => { array.push(element); },
+    'kotlin.wasm.internal.getCachedJsObject_$external_fun' : (p0, p1) => getCachedJsObject(p0, p1),
+    'kotlin.wasm.internal.utoa32_$external_fun' : (p0) => String(p0),
+    'kotlin.wasm.internal.utoa64_$external_fun' : (p0) => String(p0),
+    'kotlin.wasm.internal.itoa32_$external_fun' : (p0) => String(p0),
+    'kotlin.wasm.internal.itoa64_$external_fun' : (p0) => String(p0),
+    'kotlin.js.jsArrayGet' : (array, index) => array[index],
+    'kotlin.js.length_$external_prop_getter' : (_this) => _this.length,
+    'kotlin.js.stackPlaceHolder_js_code' : () => (''),
+    'kotlin.js.message_$external_prop_getter' : (_this) => _this.message,
+    'kotlin.js.name_$external_prop_setter' : (_this, v) => _this.name = v,
+    'kotlin.js.stack_$external_prop_getter' : (_this) => _this.stack,
+    'kotlin.js.kotlinException_$external_prop_getter' : (_this) => _this.kotlinException,
+    'kotlin.js.kotlinException_$external_prop_setter' : (_this, v) => _this.kotlinException = v,
+    'kotlin.js.JsError_$external_class_instanceof' : (x) => x instanceof Error,
+    'kotlin.js.JsString_$external_class_instanceof' : (x) => typeof x === 'string',
+    'kotlin.js.JsString_$external_class_get' : () => JsString,
+    'kotlin.js.Promise_$external_fun' : (p0) => new Promise(p0),
+    'kotlin.js.__callJsClosure_((Js?)->Unit)' : (f, p0) => f(p0),
+    'kotlin.js.__callJsClosure_((Js)->Unit)' : (f, p0) => f(p0),
+    'kotlin.js.__convertKotlinClosureToJsClosure_2' : (f, trampoline) => getCachedJsObject(f, (p0, p1) => trampoline(f, p0, p1)),
+    'kotlin.js.then_$external_fun' : (_this, p0) => _this.then(p0),
+    'kotlin.js.__convertKotlinClosureToJsClosure_1' : (f, trampoline) => getCachedJsObject(f, (p0) => trampoline(f, p0)),
+    'kotlin.js.then_$external_fun_1' : (_this, p0, p1) => _this.then(p0, p1),
+    'kotlin.js.catch_$external_fun' : (_this, p0) => _this.catch(p0),
+    'kotlin.js.Promise_$external_class_instanceof' : (x) => x instanceof Promise,
+    'kotlin.js.Promise_$external_class_get' : () => Promise,
+    'kotlin.random.initialSeed' : () => ((Math.random() * Math.pow(2, 32)) | 0),
+    'kotlin.wasm.internal.getJsClassName' : (jsKlass) => jsKlass.name,
+    'kotlin.wasm.internal.instanceOf' : (ref, jsKlass) => ref instanceof jsKlass,
+    'kotlin.wasm.internal.getConstructor' : (obj) => obj.constructor,
+    'kotlin.time.Date_$external_fun' : () => new Date(),
+    'kotlin.time.getTime_$external_fun' : (_this, ) => _this.getTime(),
+    'kotlin.time.tryGetPerformance' : () => typeof globalThis !== 'undefined' && typeof globalThis.performance !== 'undefined' ? globalThis.performance : null,
+    'kotlin.time.getPerformanceNow' : (performance) => performance.now(),
+    'kotlin.time.dateNow' : () => Date.now(),
+    'kotlinx.coroutines.tryGetProcess' : () => (typeof(process) !== 'undefined' && typeof(process.nextTick) === 'function') ? process : null,
+    'kotlinx.coroutines.tryGetWindow' : () => (typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null,
+    'kotlinx.coroutines.nextTick_$external_fun' : (_this, p0) => _this.nextTick(p0),
+    'kotlinx.coroutines.__convertKotlinClosureToJsClosure_0' : (f, trampoline) => getCachedJsObject(f, () => trampoline(f, )),
+    'kotlinx.coroutines.createScheduleMessagePoster' : (process) => () => Promise.resolve(0).then(process),
+    'kotlinx.coroutines.__callJsClosure_(()->Unit)' : (f, ) => f(),
+    'kotlinx.coroutines.createRescheduleMessagePoster' : (window) => () => window.postMessage('dispatchCoroutine', '*'),
+    'kotlinx.coroutines.subscribeToWindowMessages' : (window, process) => {
+        const handler = (event) => {
+            if (event.source == window && event.data == 'dispatchCoroutine') {
+                event.stopPropagation();
+                process();
+            }
+        }
+        window.addEventListener('message', handler, true);
+    },
+    'kotlinx.coroutines.setTimeout' : (window, handler, timeout) => window.setTimeout(handler, timeout),
+    'kotlinx.coroutines.clearTimeout' : (handle) => { if (typeof clearTimeout !== 'undefined') clearTimeout(handle); },
+    'kotlinx.coroutines.clearTimeout_$external_fun' : (_this, p0) => _this.clearTimeout(p0),
+    'kotlinx.coroutines.setTimeout_$external_fun' : (p0, p1) => setTimeout(p0, p1),
+    'kotlinx.coroutines.promiseSetDeferred' : (promise, deferred) => promise.deferred = deferred,
+    'kotlinx.coroutines.internal.throwAsyncJsError' : (message, className, stack) => { 
+            var error = new Error();
+            error.message = message;
+            error.name = className;
+            error.stack = stack;
+            if (typeof globalThis.reportError === 'function') {
+                // Up-to-date browsers and some non-browser JS runtimes (Deno, Bun)
+                globalThis.reportError(error);
+            } else {
+                // Fallback for old browsers (pre-2022), Node.js
+                setTimeout(function () { throw error }, 0);
+            }
+         },
+    'kotlinx.io.node.sep_$external_prop_getter' : (_this) => _this.sep,
+    'kotlinx.io.getPlatformName' : 
+        () => (typeof navigator !== "undefined" && navigator.platform) || "unknown"
+    ,
+    'kotlinx.io.node.loadBuffer' : ((module) => () => module)(((typeof process !== 'undefined') && (process.release.name === 'node')) ? await import(/* webpackIgnore: true */'node:buffer') : null),
+    'kotlinx.io.node.loadOs' : ((module) => () => module)(((typeof process !== 'undefined') && (process.release.name === 'node')) ? await import(/* webpackIgnore: true */'node:os') : null),
+    'kotlinx.io.node.loadPath' : ((module) => () => module)(((typeof process !== 'undefined') && (process.release.name === 'node')) ? await import(/* webpackIgnore: true */'node:path') : null),
+    'kotlinx.io.node.loadFs' : ((module) => () => module)(((typeof process !== 'undefined') && (process.release.name === 'node')) ? await import(/* webpackIgnore: true */'node:fs') : null),
+    'org.khronos.webgl.getMethodImplForUint8Array' : (obj, index) => obj[index],
+    'org.khronos.webgl.slice_$external_fun' : (_this, p0, p1, isDefault0) => _this.slice(p0, isDefault0 ? undefined : p1, ),
+    'org.khronos.webgl.Uint8Array_$external_fun' : (p0, p1, p2, isDefault0, isDefault1) => new Uint8Array(p0, isDefault0 ? undefined : p1, isDefault1 ? undefined : p2, ),
+    'org.khronos.webgl.length_$external_prop_getter' : (_this) => _this.length,
+    'org.khronos.webgl.buffer_$external_prop_getter' : (_this) => _this.buffer,
+    'org.khronos.webgl.byteOffset_$external_prop_getter' : (_this) => _this.byteOffset,
+    'org.khronos.webgl.byteLength_$external_prop_getter' : (_this) => _this.byteLength,
+    'org.w3c.dom.events.type_$external_prop_getter' : (_this) => _this.type,
+    'org.w3c.dom.events.addEventListener_$external_fun' : (_this, p0, p1, p2) => _this.addEventListener(p0, p1, p2),
+    'org.w3c.dom.events.addEventListener_$external_fun_1' : (_this, p0, p1) => _this.addEventListener(p0, p1),
+    'org.w3c.dom.events.removeEventListener_$external_fun' : (_this, p0, p1) => _this.removeEventListener(p0, p1),
+    'org.w3c.dom.AddEventListenerOptions_js_code' : (passive, once, capture) => ({ passive: passive, once: once, capture: capture }),
+    'org.w3c.dom.readyState_$external_prop_getter' : (_this) => _this.readyState,
+    'org.w3c.dom.protocol_$external_prop_getter' : (_this) => _this.protocol,
+    'org.w3c.dom.binaryType_$external_prop_setter' : (_this, v) => _this.binaryType = v,
+    'org.w3c.dom.close_$external_fun' : (_this, p0, p1, isDefault0, isDefault1) => _this.close(isDefault0 ? undefined : p0, isDefault1 ? undefined : p1, ),
+    'org.w3c.dom.send_$external_fun' : (_this, p0) => _this.send(p0),
+    'org.w3c.dom.send_$external_fun_1' : (_this, p0) => _this.send(p0),
+    'org.w3c.dom.OPEN_$external_prop_getter' : (_this) => _this.OPEN,
+    'org.w3c.dom.Companion_$external_object_getInstance' : () => WebSocket,
+    'org.w3c.dom.data_$external_prop_getter' : (_this) => _this.data,
+    'org.w3c.dom.code_$external_prop_getter' : (_this) => _this.code,
+    'org.w3c.dom.reason_$external_prop_getter' : (_this) => _this.reason,
+    'org.w3c.dom.Companion_$external_object_getInstance_1' : () => ({}),
+    'org.w3c.fetch.status_$external_prop_getter' : (_this) => _this.status,
+    'org.w3c.fetch.statusText_$external_prop_getter' : (_this) => _this.statusText,
+    'org.w3c.fetch.headers_$external_prop_getter' : (_this) => _this.headers,
+    'org.w3c.fetch.body_$external_prop_getter' : (_this) => _this.body,
+    'org.w3c.fetch.get_$external_fun' : (_this, p0) => _this.get(p0),
+    'org.w3c.fetch.Companion_$external_object_getInstance' : () => ({}),
+    'io.ktor.utils.io.js.decode' : (decoder, buffer) => { try { return decoder.decode(buffer) } catch(e) { return null } },
+    'io.ktor.utils.io.js.tryCreateTextDecoder' : (encoding, fatal) => { try { return new TextDecoder(encoding, { fatal: fatal }) } catch(e) { return null } },
+    'io.ktor.utils.io.charsets.toJsArrayImpl' : (x) => new Int8Array(x),
+    'io.ktor.util.date.Date_$external_fun' : () => new Date(),
+    'io.ktor.util.date.Date_$external_fun_1' : (p0) => new Date(p0),
+    'io.ktor.util.date.getTime_$external_fun' : (_this, ) => _this.getTime(),
+    'io.ktor.util.date.getUTCDate_$external_fun' : (_this, ) => _this.getUTCDate(),
+    'io.ktor.util.date.getUTCDay_$external_fun' : (_this, ) => _this.getUTCDay(),
+    'io.ktor.util.date.getUTCFullYear_$external_fun' : (_this, ) => _this.getUTCFullYear(),
+    'io.ktor.util.date.getUTCHours_$external_fun' : (_this, ) => _this.getUTCHours(),
+    'io.ktor.util.date.getUTCMinutes_$external_fun' : (_this, ) => _this.getUTCMinutes(),
+    'io.ktor.util.date.getUTCMonth_$external_fun' : (_this, ) => _this.getUTCMonth(),
+    'io.ktor.util.date.getUTCSeconds_$external_fun' : (_this, ) => _this.getUTCSeconds(),
+    'io.ktor.util.hasNodeApi' : () => 
+    (typeof process !== 'undefined' 
+        && process.versions != null 
+        && process.versions.node != null) ||
+    (typeof window !== 'undefined' 
+        && typeof window.process !== 'undefined' 
+        && window.process.versions != null 
+        && window.process.versions.node != null)
+    ,
+    'io.ktor.util.logging.getKtorLogLevel' : () => process ? process.env.KTOR_LOG_LEVEL : null,
+    'io.ktor.util.logging.warn_$external_fun' : (_this, p0) => _this.warn(p0),
+    'io.ktor.util.logging.debug_$external_fun' : (_this, p0) => _this.debug(p0),
+    'io.ktor.util.logging.console_$external_prop_getter' : () => console,
+    'io.ktor.http.locationOrigin' : () => function() {
+        var tmpLocation = null
+        if (typeof window !== 'undefined') {
+          tmpLocation = window.location
+        } else if (typeof self !== 'undefined') {
+          tmpLocation = self.location
+        }
+        var origin = ""
+        if (tmpLocation) {
+          origin = tmpLocation.origin
+        }
+        return origin && origin != "null" ? origin : "http://localhost"    
+    }(),
+    'io.ktor.client.engine.js.createBrowserWebSocket' : (urlString_capturingHack, protocols) => new WebSocket(urlString_capturingHack, protocols),
+    'io.ktor.client.engine.js.createWebSocketNodeJs' : (socketCtor, urlString_capturingHack, headers_capturingHack, protocols) => new socketCtor(urlString_capturingHack, protocols, { headers: headers_capturingHack }),
+    'io.ktor.client.engine.js.getKeys' : (headers) => Array.from(headers.keys()),
+    'io.ktor.client.engine.js.compatibility.abortControllerCtorBrowser' : () => AbortController,
+    'io.ktor.client.fetch.body_$external_prop_setter' : (_this, v) => _this.body = v,
+    'io.ktor.client.fetch.headers_$external_prop_setter' : (_this, v) => _this.headers = v,
+    'io.ktor.client.fetch.method_$external_prop_setter' : (_this, v) => _this.method = v,
+    'io.ktor.client.fetch.redirect_$external_prop_setter' : (_this, v) => _this.redirect = v,
+    'io.ktor.client.fetch.signal_$external_prop_setter' : (_this, v) => _this.signal = v,
+    'io.ktor.client.fetch.fetch_$external_fun' : (p0, p1, isDefault0) => fetch(p0, isDefault0 ? undefined : p1, ),
+    'io.ktor.client.fetch.signal_$external_prop_getter' : (_this) => _this.signal,
+    'io.ktor.client.fetch.abort_$external_fun' : (_this, ) => _this.abort(),
+    'io.ktor.client.fetch.getReader_$external_fun' : (_this, ) => _this.getReader(),
+    'io.ktor.client.fetch.cancel_$external_fun' : (_this, p0, isDefault0) => _this.cancel(isDefault0 ? undefined : p0, ),
+    'io.ktor.client.fetch.read_$external_fun' : (_this, ) => _this.read(),
+    'io.ktor.client.fetch.done_$external_prop_getter' : (_this) => _this.done,
+    'io.ktor.client.fetch.value_$external_prop_getter' : (_this) => _this.value,
+    'io.ktor.client.plugins.websocket.tryGetEventDataAsString' : (data) => typeof(data) === 'string' ? data : null,
+    'io.ktor.client.plugins.websocket.tryGetEventDataAsArrayBuffer' : (data) => data instanceof ArrayBuffer ? data : null,
+    'io.ktor.client.utils.makeJsObject' : () => { return {}; },
+    'io.ktor.client.utils.makeImport' : (name) => import(name),
+    'io.ktor.client.utils.makeJsCall' : (func, arg) => func.apply(null, arg),
+    'io.ktor.client.utils.jsObjectAssign' : () => Object.assign,
+    'io.ktor.client.utils.makeJsNew' : (ctor) => new ctor(),
+    'io.ktor.client.utils.getObjectField' : (obj, name) => obj[name],
+    'io.ktor.client.utils.setObjectField' : (obj, name, value) => obj[name]=value,
+    'io.ktor.client.utils.eventAsString' : (event) => JSON.stringify(event, ['message', 'target', 'type', 'isTrusted']),
+    'io.ktor.client.utils.toJsArrayImpl' : (x) => new Uint8Array(x),
+    'ee.schimke.livery.client.asUint8' : (buffer) => new Uint8Array(buffer),
+    'ee.schimke.livery.client.digest' : (data) => crypto.subtle.digest('SHA-256', data),
+    'ee.schimke.livery.client.importEd25519' : (key) => crypto.subtle.importKey('raw', key, { name: 'Ed25519' }, false, ['verify']),
+    'ee.schimke.livery.client.verify' : (key, signature, message) => crypto.subtle.verify({ name: 'Ed25519' }, key, signature, message),
+    'ee.schimke.livery.client.uint8Length' : (a) => a.length,
+    'ee.schimke.livery.client.getUint8' : (a, i) => a[i],
+    'ee.schimke.livery.client.newUint8' : (size) => new Uint8Array(size),
+    'ee.schimke.livery.client.setUint8' : (a, i, v) => { a[i] = v; },
+    'ee.schimke.composeai.rcplayer.trace.performanceMark' : (name) => { try { performance.mark(name); } catch (e) {} },
+    'ee.schimke.composeai.rcplayer.trace.performanceMeasure' : (name, startMark) => { try { performance.measure(name, startMark); } catch (e) {} },
+    'ee.schimke.composeai.rcplayer.trace.performanceClearMarks' : (name) => { try { performance.clearMarks(name); } catch (e) {} },
+    'kotlinx.datetime.internal.Date_$external_fun' : (p0) => new Date(p0),
+    'kotlinx.datetime.internal.getTimezoneOffset_$external_fun' : (_this, ) => _this.getTimezoneOffset(),
+    'kotlinx.datetime.internal.JSJoda.ZoneRulesProvider_$external_object_getInstance' : () => _ref_QGpzLWpvZGEvY29yZQ_.ZoneRulesProvider,
+    'kotlinx.datetime.internal.JSJoda.id_$external_fun' : (_this, ) => _this.id(),
+    'kotlinx.datetime.internal.JSJoda.systemDefault_$external_fun' : (_this, ) => _this.systemDefault(),
+    'kotlinx.datetime.internal.JSJoda.Companion_$external_object_getInstance' : () => _ref_QGpzLWpvZGEvY29yZQ_.ZoneId,
+    'kotlinx.datetime.internal.withCaughtJsException' : (body) => {
+        try {
+            body();
+            return null;
+        } catch(e) {
+            return e;
+        }
+    },
+    'kotlinx.datetime.internal.getExceptionMessage' : (jsException) => jsException.message,
+    'kotlinx.datetime.internal.getZones' : (rulesProvider) => rulesProvider.getTzdbData().zones,
+    'kotlinx.datetime.internal.getLinks' : (rulesProvider) => rulesProvider.getTzdbData().links,
+    'ee.schimke.livery.web.openDatabase' : () => new Promise((resolve, reject) => {
+      if (!globalThis.navigator?.locks) { reject(new Error('Persistent Livery caching requires Web Locks on a secure origin; use persistentCache: false otherwise')); return; }
+      const request = indexedDB.open('livery-v1', 1);
+      request.onupgradeneeded = () => request.result.createObjectStore('entries');
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => reject(new Error('Livery IndexedDB upgrade blocked'));
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+      };
+    }),
+    'ee.schimke.livery.web.read' : (db, key) => new Promise((resolve, reject) => {
+      const tx = db.transaction('entries', 'readonly');
+      const request = tx.objectStore('entries').get(key);
+      tx.oncomplete = () => resolve(request.result ?? null);
+      tx.onabort = () => reject(tx.error);
+      tx.onerror = () => reject(tx.error);
+    }),
+    'ee.schimke.livery.web.write' : (db, key, value) => new Promise((resolve, reject) => {
+      const tx = db.transaction('entries', 'readwrite');
+      tx.objectStore('entries').put(value, key);
+      tx.oncomplete = () => resolve(null);
+      tx.onabort = () => reject(tx.error);
+      tx.onerror = () => reject(tx.error);
+    }),
+    'ee.schimke.livery.web.keys' : (db, prefix) => new Promise((resolve, reject) => {
+      const tx = db.transaction('entries', 'readonly');
+      const request = tx.objectStore('entries').getAllKeys(IDBKeyRange.bound(prefix, prefix + '\uffff'));
+      tx.oncomplete = () => resolve(JSON.stringify(request.result.map(key => key.slice(prefix.length))));
+      tx.onabort = () => reject(tx.error);
+      tx.onerror = () => reject(tx.error);
+    }),
+    'ee.schimke.livery.web.browserRefreshLock' : (name, block) => {
+      if (!globalThis.navigator?.locks) throw new Error('Persistent Livery caching requires Web Locks on a secure origin; use persistentCache: false otherwise');
+      return navigator.locks.request(name, {mode: 'exclusive'}, () => block());
+    }
+}
+
+const StringConstantsProxy = new Proxy({}, {
+  get(_, prop) { return prop; }
+});
+
+export { wasmTag as __TAG };
+
+export const importObject = {
+    js_code,
+    intrinsics: {
+        memory: new WebAssembly.Memory({ initial: 0 }),
+        tag: wasmTag
+    },
+    "'": StringConstantsProxy,
+    'wasm:js-string': d2FzbTpqcy1zdHJpbmc,
+};
+    

package/dist/livery-web/livery-livery-web.js-builtins.mjs

@@ -0,0 +1,52 @@
+export const length = (s) => s.length
+export const concat = (a, b) => a + b
+export const charCodeAt = (s, i) => s.charCodeAt(i >>> 0)
+export const substring = (s, start, end) => {
+    start >>>= 0;
+    end >>>= 0;
+    return s.substring(start, end);
+}
+
+export const compare = (a, b) => {
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+
+export const equals = (a, b) => a === b ? 1 : 0
+const moduleFromCharCodeArray = new WebAssembly.Module(new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x02, 0x5e,
+  0x77, 0x01, 0x60, 0x02, 0x64, 0x00, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01,
+  0x01, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x31, 0x36, 0x5f, 0x67, 0x65, 0x74,
+  0x00, 0x00, 0x0a, 0x0b, 0x01, 0x09, 0x00, 0x20, 0x00, 0x20, 0x01, 0xfb,
+  0x0d, 0x00, 0x0b, 0x00, 0x13, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x0c,
+  0x01, 0x00, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5f, 0x69, 0x31, 0x36
+]));
+const helpersFromCharCodeArray = new WebAssembly.Instance(moduleFromCharCodeArray).exports;
+
+export const fromCharCodeArray = (array, start, end) => {
+    start >>>= 0;
+    end >>>= 0;
+    let result = [];
+    for (let i = start; i < end; i++) {
+        result.push(String.fromCharCode(helpersFromCharCodeArray.a16_get(array, i)));
+    }
+    return result.join("");
+}
+
+const moduleIntoCharCode = new WebAssembly.Module(new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x02, 0x5e,
+  0x77, 0x01, 0x60, 0x03, 0x64, 0x00, 0x7f, 0x7f, 0x00, 0x03, 0x02, 0x01,
+  0x01, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x31, 0x36, 0x5f, 0x73, 0x65, 0x74,
+  0x00, 0x00, 0x0a, 0x0d, 0x01, 0x0b, 0x00, 0x20, 0x00, 0x20, 0x01, 0x20,
+  0x02, 0xfb, 0x0e, 0x00, 0x0b, 0x00, 0x13, 0x04, 0x6e, 0x61, 0x6d, 0x65,
+  0x04, 0x0c, 0x01, 0x00, 0x09, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5f, 0x69,
+  0x31, 0x36
+]));
+const helpersIntoCharCode = new WebAssembly.Instance(moduleIntoCharCode).exports;
+
+export const intoCharCodeArray = (s, array, start) => {
+    start >>>= 0;
+    for (let i = 0; i < s.length; i++) {
+      helpersIntoCharCode.a16_set(array, start + i, s.charCodeAt(i));
+    }
+    return s.length;
+}

package/dist/livery-web/livery-livery-web.mjs

@@ -0,0 +1,104 @@
+
+
+import { importObject, setWasmExports } from './livery-livery-web.import-object.mjs'
+
+let wasmInstance;
+
+const wasmOptions = { builtins: ['js-string'], importedStringConstants: "'" }
+
+try {
+  if ((typeof process !== 'undefined') && (process.release.name === 'node')) {
+    const fs = await import(/* webpackIgnore: true */'node:fs');
+    const url = await import(/* webpackIgnore: true */'node:url');
+    const filepath = import.meta.resolve('./livery-livery-web.wasm');
+    const wasmBuffer = fs.readFileSync(url.fileURLToPath(filepath));
+    const wasmModule = new WebAssembly.Module(wasmBuffer, wasmOptions);
+    wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+  } else if (typeof Deno !== 'undefined') {
+    const path = await import(/* webpackIgnore: true */'https://deno.land/std/path/mod.ts');
+    const binary = Deno.readFileSync(path.fromFileUrl(import.meta.resolve('./livery-livery-web.wasm')));
+    const module = await WebAssembly.compile(binary, wasmOptions);
+    wasmInstance = await WebAssembly.instantiate(module, importObject);
+  } else if (
+    (typeof d8 !== 'undefined' // V8
+      || typeof inIon !== 'undefined' // SpiderMonkey
+      || typeof jscOptions !== 'undefined' // JavaScriptCore
+    )
+  ) {
+    const filepath = import.meta.url.replace(/\.mjs$/, '.wasm');
+    const wasmBuffer = read(filepath, 'binary');
+    const wasmModule = new WebAssembly.Module(wasmBuffer, wasmOptions);
+    wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+  } else {
+    wasmInstance = (await WebAssembly.instantiateStreaming(fetch(new URL('./livery-livery-web.wasm',import.meta.url).href), importObject, wasmOptions)).instance;
+  }
+} catch (e) {
+  if (e instanceof WebAssembly.CompileError) {
+    let text = `Please make sure that your runtime environment supports the latest version of Wasm GC and Exception-Handling proposals.
+For more information, see https://kotl.in/wasm-help
+`;
+    if (typeof console !== "undefined" && console.error !== void 0) {
+      console.error(text);
+    } else {
+      const t = "\n" + text;
+      if (typeof console !== "undefined" && console.log !== void 0)
+        console.log(t);
+      else
+        print(t);
+    }
+  }
+  throw e;
+}
+
+const exports = wasmInstance.exports
+
+let memoryFirstTimeAccess = true;
+const memoryProxy = new Proxy(importObject.intrinsics.memory, {
+    get(target, prop, receiver) {
+        if (memoryFirstTimeAccess) {
+            memoryFirstTimeAccess = false;
+            console.error('Accessing `memory` via `wasmExports` is deprecated. Use `kotlin.wasm.unsafe.wasmMemory` or update dependencies. Read more: https://kotl.in/vr3szr');
+        }
+        return Reflect.get(target, prop);
+    }
+});
+const wasmExports = new Proxy(memoryProxy, {
+    get(target, prop, receiver) {
+        if (prop == 'memory') {
+            return target;
+        } else {
+            throw new Error('Accessing exports via `wasmExports` is no longer supported. Remove usages or update dependencies. Read more: https://kotl.in/vr3szr');
+        }
+    }
+});
+
+const wasmMemory = wasmExports.memory;
+export { wasmMemory as memory }
+
+export const {
+    previewCreate,
+    previewConnect,
+    previewRefresh,
+    previewRender,
+    previewFetchImages,
+    previewShown,
+    previewRelease,
+    previewAction,
+    previewEvents,
+    previewClose,
+    liveryOpen,
+    liveryRefresh,
+    liveryComponents,
+    liveryCatalogSchema,
+    liveryRender,
+    liveryFetchImages,
+    liveryFetchPending,
+    liveryShown,
+    liveryRelease,
+    liveryAction,
+    liveryEvents,
+    liveryClose
+} = exports
+
+setWasmExports(wasmExports);
+

package/dist/livery-web-compose/fonts/NotoSansSymbols2-OFL.txt

@@ -0,0 +1,117 @@
+Copyright 2010,2012-2020 Google Inc.; 2015-2020 Google LLC.
+
+SIL OPEN FONT LICENSE Version 1.1
+
+PREAMBLE
+
+The goals of the Open Font License (OFL) are to stimulate
+worldwide development of collaborative font projects,
+to support the font creation efforts
+of academic and linguistic communities,
+and to provide a free and open framework
+in which fonts may be shared and improved
+in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied,
+modified and redistributed freely
+as long as they are not sold by themselves.
+The fonts, including any derivative works,
+can be bundled, embedded,
+redistributed and/or sold with any software
+provided that any reserved names are not used
+by derivative works.
+The fonts and derivatives, however,
+cannot be released under any other type of license.
+The requirement for fonts to remain under this license
+does not apply to any document
+created using the fonts or their derivatives.
+
+DEFINITIONS
+
+"Font Software" refers to the set of files
+released by the Copyright Holder(s) under this license
+and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such
+after the copyright statement(s).
+
+"Original Version" refers to the collection
+of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative
+made by adding to, deleting, or substituting --
+in part or in whole --
+any of the components of the Original Version,
+by changing formats
+or by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer,
+technical writer or other person
+who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge,
+to any person obtaining a copy of the Font Software,
+to use, study, copy, merge, embed, modify, redistribute,
+and sell modified and unmodified copies of the Font Software,
+subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions,
+may be sold by itself.
+
+2) Original or Modified Versions of the Font Software
+may be bundled, redistributed and/or sold with any software,
+provided that each copy contains the above copyright notice
+and this license.
+These can be included either as stand-alone text files,
+human-readable headers or in the appropriate
+machine-readable metadata fields within text or binary files
+as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use
+the Reserved Font Name(s)
+unless explicit written permission is granted
+by the corresponding Copyright Holder.
+This restriction only applies to the primary font name
+as presented to the users.
+
+4) The name(s) of the Copyright Holder(s)
+or the Author(s) of the Font Software
+shall not be used to promote,
+endorse or advertise any Modified Version,
+except to acknowledge the contribution(s)
+of the Copyright Holder(s) and the Author(s)
+or with their explicit written permission.
+
+5) The Font Software,
+modified or unmodified, in part or in whole,
+must be distributed entirely under this license,
+and must not be distributed under any other license.
+The requirement for fonts to remain under this license
+does not apply to any document
+created using the Font Software.
+
+TERMINATION
+
+This license becomes null and void
+if any of the above conditions are not met.
+
+DISCLAIMER
+
+THE FONT SOFTWARE IS PROVIDED "AS IS",
+WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO
+ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF THE USE OR INABILITY TO USE
+THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/livery-web-compose/fonts/README.md

@@ -0,0 +1,8 @@
+Roboto Flex is bundled from rc-players' `rc-player/wasm/dist-assets/fonts/RobotoFlex.ttf`
+at commit `adde1014109cced19f70551764b3604fad55c50b`.
+It is distributed under the accompanying SIL Open Font License. The catalog prepares it before
+mounting players; the synchronous typeface loader never fetches during composition or drawing.
+
+Noto Sans Symbols 2 comes from Debian fonts-noto-core (20201225-2), under the accompanying
+SIL Open Font License. Its preloaded glyphs provide fallback for symbols absent from Roboto Flex,
+including the sample banner’s U+2715 close glyph. No system-font or Google Fonts fetch is needed.