@yschimke/livery-a2ui 0.0.0-stage → 0.12.0

package/node_modules/@yschimke/livery-web/dist/livery-web/livery-livery-web-core.d.mts

@@ -0,0 +1,63 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function previewCreate(config: string): number;
+export declare function previewConnect(session: number): not.exported.kotlin.js.Promise<unknown>;
+export declare function previewRefresh(session: number): not.exported.kotlin.js.Promise<unknown>;
+export declare function previewRender(session: number, contract: string, data: string, space: string, designId: Nullable<string>, sha256: Nullable<string>): not.exported.kotlin.js.Promise<unknown>;
+export declare function previewFetchImages(session: number): not.exported.kotlin.js.Promise<unknown>;
+export declare function previewShown(session: number, render: number): void;
+export declare function previewRelease(session: number, render: number): void;
+export declare function previewAction(session: number, render: number, name: string, valueType: string, value: Nullable<string>): not.exported.kotlin.js.Promise<unknown>;
+export declare function previewEvents(session: number): string;
+export declare function previewClose(id: number): void;
+declare namespace not.exported.kotlin.js {
+    class Promise<out T> {
+        constructor(executor: (resolve: (p0: T) => void, reject: (p0: NonNullable<unknown>) => void) => void);
+        then<S>(onFulfilled: Nullable<(p0: T) => S>): not.exported.kotlin.js.Promise<S>;
+        then<S>(onFulfilled: Nullable<(p0: T) => S>, onRejected: Nullable<(p0: NonNullable<unknown>) => S>): not.exported.kotlin.js.Promise<S>;
+        catch<S>(onRejected: (p0: NonNullable<unknown>) => S): not.exported.kotlin.js.Promise<S>;
+        finally(onFinally: () => void): not.exported.kotlin.js.Promise<T>;
+        get _hashCode(): number;
+        set _hashCode(value: number);
+    }
+    namespace Promise {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new <T>() => Promise<T>;
+        }
+    }
+}
+declare namespace not.exported.kotlin.js.Promise {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                all<S>(promise: not.exported.kotlin.js.Array<not.exported.kotlin.js.Promise<S>>): not.exported.kotlin.js.Promise<not.exported.kotlin.js.Array<S>>;
+                race<S>(promise: not.exported.kotlin.js.Array<not.exported.kotlin.js.Promise<S>>): not.exported.kotlin.js.Promise<S>;
+                reject(e: NonNullable<unknown>): not.exported.kotlin.js.Promise<never>;
+                resolve<S>(e: S): not.exported.kotlin.js.Promise<S>;
+                resolve<S>(e: not.exported.kotlin.js.Promise<S>): not.exported.kotlin.js.Promise<S>;
+                get _hashCode(): number;
+                set _hashCode(value: number);
+                private constructor();
+            }
+        }
+    }
+}
+declare namespace not.exported.kotlin.js {
+    class Array<T> {
+        constructor();
+        get length(): number;
+        get _hashCode(): number;
+        set _hashCode(value: number);
+    }
+    namespace Array {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new <T>() => Array<T>;
+        }
+    }
+}

package/node_modules/@yschimke/livery-web/dist/livery-web/livery-livery-web-core.import-object.mjs

@@ -0,0 +1,333 @@
+
+import * as QGpzLWpvZGEvY29yZQ from '@js-joda/core';
+import * as d2FzbTpqcy1zdHJpbmc from './livery-livery-web-core.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
+}
+
+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/node_modules/@yschimke/livery-web/dist/livery-web/livery-livery-web-core.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/node_modules/@yschimke/livery-web/dist/livery-web/livery-livery-web-core.mjs

@@ -0,0 +1,92 @@
+
+
+import { importObject, setWasmExports } from './livery-livery-web-core.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-core.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-core.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-core.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
+} = exports
+
+setWasmExports(wasmExports);
+

package/node_modules/@yschimke/livery-web/dist/player.d.ts

@@ -0,0 +1,65 @@
+import type { HostValue } from '../vendor/remote-compose-player.mjs';
+/** A host named action the document sent: its name and value, as the player reported them. */
+export interface NamedAction {
+    name: string;
+    valueType: 'none' | 'string' | 'int' | 'float';
+    value: unknown;
+}
+/** A persistent in-page renderer. Superseded shows resolve false; dispose cancels pending work. */
+export interface LiveryPlayer {
+    /** Finite wrap-content height when supported by this player. */
+    readonly measuredHeightDp?: number;
+    show(key: string, document: Uint8Array, values: Record<string, HostValue>, widthPx: number, heightPx: number, density: number): Promise<boolean>;
+    resize(widthPx: number, heightPx: number, density: number): void;
+    forget(): void;
+    dispose(): void;
+    readonly stats: {
+        loads: number;
+        sets: number;
+    };
+}
+export type LiveryPlayerFactory = (container: HTMLElement, onAction: (action: NamedAction) => void) => LiveryPlayer;
+/**
+ * The TypeScript Remote Compose player on a canvas in [container], in the page itself. A document
+ * is loaded once; its named values are set on it while it plays, so a data change moves the values
+ * and never reloads the document (Remote Compose's model, as `LiveryTemplate` does on Compose).
+ */
+export declare class RcCanvasPlayer implements LiveryPlayer {
+    private readonly onAction;
+    private readonly options;
+    private readonly handle;
+    private host;
+    private key?;
+    private geometry?;
+    private values;
+    /** Shows run one after another; one asked for while another runs replaces any still queued. */
+    private queue;
+    private latest;
+    /** Last root layout height, in dp, after applying named values. */
+    measuredHeightDp?: number;
+    private disposed;
+    private epoch;
+    /** Documents loaded and values set, for tests and debugging. */
+    readonly stats: {
+        loads: number;
+        sets: number;
+    };
+    constructor(container: HTMLElement, onAction: (a: NamedAction) => void, options?: {
+        reloadOnResize?: boolean;
+    });
+    private bindHost;
+    /**
+     * Shows [documentKey]'s document with [values]: loads [document] only when the key differs from
+     * the one playing, then sets each value that changed. A load is asynchronous, so shows are
+     * queued: each waits for the one before it, and a show superseded while it waits does nothing
+     * (resolves `false`), so an older one can never land after a newer one.
+     */
+    show(documentKey: string, document: Uint8Array, values: Record<string, HostValue>, widthPx: number, heightPx: number, density: number): Promise<boolean>;
+    private apply;
+    /** The canvas at [widthPx] × [heightPx] CSS pixels. */
+    resize(widthPx: number, heightPx: number, density: number): void;
+    /** Forgets the document playing, so the next [show] loads its document again. */
+    forget(): void;
+    dispose(): void;
+}
+export type { HostValue } from '../vendor/remote-compose-player.mjs';