@affectively/aeon-pages 1.3.0

package/packages/runtime/wasm/aeon_pages_runtime.js

@@ -0,0 +1,1657 @@
+/* @ts-self-types="./aeon_pages_runtime.d.ts" */
+
+/**
+ * The Aeon Router - matches URLs to routes
+ */
+export class AeonRouter {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AeonRouterFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_aeonrouter_free(ptr, 0);
+  }
+  /**
+   * Add a route to the router
+   * @param {RouteDefinition} definition
+   */
+  add_route(definition) {
+    _assertClass(definition, RouteDefinition);
+    var ptr0 = definition.__destroy_into_raw();
+    wasm.aeonrouter_add_route(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * Get all registered routes (for debugging)
+   * @returns {string}
+   */
+  get_routes_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.aeonrouter_get_routes_json(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Check if a route exists for the given path
+   * @param {string} path
+   * @returns {boolean}
+   */
+  has_route(path) {
+    const ptr0 = passStringToWasm0(
+      path,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.aeonrouter_has_route(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Match a URL path to a route
+   * @param {string} path
+   * @returns {RouteMatch | undefined}
+   */
+  match_route(path) {
+    const ptr0 = passStringToWasm0(
+      path,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.aeonrouter_match_route(this.__wbg_ptr, ptr0, len0);
+    return ret === 0 ? undefined : RouteMatch.__wrap(ret);
+  }
+  constructor() {
+    const ret = wasm.aeonrouter_new();
+    this.__wbg_ptr = ret >>> 0;
+    AeonRouterFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose)
+  AeonRouter.prototype[Symbol.dispose] = AeonRouter.prototype.free;
+
+/**
+ * Asset Manifest for inlining images/SVGs
+ */
+export class AssetManifest {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(AssetManifest.prototype);
+    obj.__wbg_ptr = ptr;
+    AssetManifestFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AssetManifestFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_assetmanifest_free(ptr, 0);
+  }
+  /**
+   * Load manifest from JSON
+   * @param {string} json
+   * @returns {AssetManifest}
+   */
+  static from_json(json) {
+    const ptr0 = passStringToWasm0(
+      json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.assetmanifest_from_json(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return AssetManifest.__wrap(ret[0]);
+  }
+  /**
+   * Get data URI for an asset path
+   * @param {string} path
+   * @returns {string | undefined}
+   */
+  get_data_uri(path) {
+    const ptr0 = passStringToWasm0(
+      path,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.assetmanifest_get_data_uri(this.__wbg_ptr, ptr0, len0);
+    let v2;
+    if (ret[0] !== 0) {
+      v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v2;
+  }
+  constructor() {
+    const ret = wasm.assetmanifest_new();
+    this.__wbg_ptr = ret >>> 0;
+    AssetManifestFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose)
+  AssetManifest.prototype[Symbol.dispose] = AssetManifest.prototype.free;
+
+/**
+ * CSS Manifest for on-demand CSS generation
+ */
+export class CSSManifest {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(CSSManifest.prototype);
+    obj.__wbg_ptr = ptr;
+    CSSManifestFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    CSSManifestFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_cssmanifest_free(ptr, 0);
+  }
+  /**
+   * Get critical CSS
+   * @returns {string}
+   */
+  get critical() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.cssmanifest_critical(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Load manifest from JSON
+   * @param {string} json
+   * @returns {CSSManifest}
+   */
+  static from_json(json) {
+    const ptr0 = passStringToWasm0(
+      json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cssmanifest_from_json(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return CSSManifest.__wrap(ret[0]);
+  }
+  /**
+   * @param {string} critical
+   */
+  constructor(critical) {
+    const ptr0 = passStringToWasm0(
+      critical,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cssmanifest_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    CSSManifestFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose)
+  CSSManifest.prototype[Symbol.dispose] = CSSManifest.prototype.free;
+
+/**
+ * Component registry - maps component names to their render functions
+ */
+export class ComponentRegistry {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ComponentRegistryFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_componentregistry_free(ptr, 0);
+  }
+  /**
+   * Check if a component is registered
+   * @param {string} name
+   * @returns {boolean}
+   */
+  has(name) {
+    const ptr0 = passStringToWasm0(
+      name,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.componentregistry_has(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Get all registered component names
+   * @returns {string}
+   */
+  list() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.componentregistry_list(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  constructor() {
+    const ret = wasm.componentregistry_new();
+    this.__wbg_ptr = ret >>> 0;
+    ComponentRegistryFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Register a component as available for rendering
+   * @param {string} name
+   */
+  register(name) {
+    const ptr0 = passStringToWasm0(
+      name,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    wasm.componentregistry_register(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * Register multiple components at once (from JSON array)
+   * @param {string} names_json
+   */
+  register_many(names_json) {
+    const ptr0 = passStringToWasm0(
+      names_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    wasm.componentregistry_register_many(this.__wbg_ptr, ptr0, len0);
+  }
+}
+if (Symbol.dispose)
+  ComponentRegistry.prototype[Symbol.dispose] =
+    ComponentRegistry.prototype.free;
+
+/**
+ * Font Manifest for embedding fonts
+ */
+export class FontManifest {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(FontManifest.prototype);
+    obj.__wbg_ptr = ptr;
+    FontManifestFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    FontManifestFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_fontmanifest_free(ptr, 0);
+  }
+  /**
+   * Get @font-face CSS
+   * @returns {string}
+   */
+  get font_face_css() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.fontmanifest_font_face_css(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Load manifest from JSON
+   * @param {string} json
+   * @returns {FontManifest}
+   */
+  static from_json(json) {
+    const ptr0 = passStringToWasm0(
+      json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fontmanifest_from_json(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return FontManifest.__wrap(ret[0]);
+  }
+  constructor() {
+    const ret = wasm.fontmanifest_new();
+    this.__wbg_ptr = ret >>> 0;
+    FontManifestFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose)
+  FontManifest.prototype[Symbol.dispose] = FontManifest.prototype.free;
+
+/**
+ * Render context containing manifests and collected data
+ */
+export class RenderContext {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RenderContextFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_rendercontext_free(ptr, 0);
+  }
+  /**
+   * Get collected CSS classes as JSON array
+   * @returns {string}
+   */
+  get_collected_classes() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.rendercontext_get_collected_classes(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Get interactive nodes as JSON array
+   * @returns {string}
+   */
+  get_interactive_nodes() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.rendercontext_get_interactive_nodes(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {string} css_manifest_json
+   * @param {string} asset_manifest_json
+   * @param {string} font_manifest_json
+   */
+  constructor(css_manifest_json, asset_manifest_json, font_manifest_json) {
+    const ptr0 = passStringToWasm0(
+      css_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      asset_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(
+      font_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.rendercontext_new(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    RenderContextFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+if (Symbol.dispose)
+  RenderContext.prototype[Symbol.dispose] = RenderContext.prototype.free;
+
+/**
+ * Route definition from the build manifest
+ */
+export class RouteDefinition {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(RouteDefinition.prototype);
+    obj.__wbg_ptr = ptr;
+    RouteDefinitionFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RouteDefinitionFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_routedefinition_free(ptr, 0);
+  }
+  /**
+   * @returns {string}
+   */
+  get component_id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.routedefinition_component_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {boolean}
+   */
+  get is_aeon() {
+    const ret = wasm.routedefinition_is_aeon(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * @returns {string | undefined}
+   */
+  get layout() {
+    const ret = wasm.routedefinition_layout(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
+  /**
+   * @param {string} pattern
+   * @param {string} session_id
+   * @param {string} component_id
+   * @param {string | null | undefined} layout
+   * @param {boolean} is_aeon
+   */
+  constructor(pattern, session_id, component_id, layout, is_aeon) {
+    const ptr0 = passStringToWasm0(
+      pattern,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      session_id,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(
+      component_id,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(layout)
+      ? 0
+      : passStringToWasm0(
+          layout,
+          wasm.__wbindgen_malloc,
+          wasm.__wbindgen_realloc,
+        );
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.routedefinition_new(
+      ptr0,
+      len0,
+      ptr1,
+      len1,
+      ptr2,
+      len2,
+      ptr3,
+      len3,
+      is_aeon,
+    );
+    this.__wbg_ptr = ret >>> 0;
+    RouteDefinitionFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @returns {string}
+   */
+  get pattern() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.routedefinition_pattern(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get session_id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.routedefinition_session_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose)
+  RouteDefinition.prototype[Symbol.dispose] = RouteDefinition.prototype.free;
+
+/**
+ * Match result with extracted parameters
+ */
+export class RouteMatch {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(RouteMatch.prototype);
+    obj.__wbg_ptr = ptr;
+    RouteMatchFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    RouteMatchFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_routematch_free(ptr, 0);
+  }
+  /**
+   * @param {string} key
+   * @returns {string | undefined}
+   */
+  get_param(key) {
+    const ptr0 = passStringToWasm0(
+      key,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.routematch_get_param(this.__wbg_ptr, ptr0, len0);
+    let v2;
+    if (ret[0] !== 0) {
+      v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v2;
+  }
+  /**
+   * @returns {string}
+   */
+  get params_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.routematch_params_json(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get resolved_session_id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.routematch_resolved_session_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {RouteDefinition}
+   */
+  get route() {
+    const ret = wasm.routematch_route(this.__wbg_ptr);
+    return RouteDefinition.__wrap(ret);
+  }
+}
+if (Symbol.dispose)
+  RouteMatch.prototype[Symbol.dispose] = RouteMatch.prototype.free;
+
+/**
+ * Serialized component tree (stored in Aeon sessions)
+ */
+export class SerializedComponent {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SerializedComponent.prototype);
+    obj.__wbg_ptr = ptr;
+    SerializedComponentFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SerializedComponentFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_serializedcomponent_free(ptr, 0);
+  }
+  /**
+   * @param {SerializedComponent} component
+   */
+  add_component_child(component) {
+    _assertClass(component, SerializedComponent);
+    var ptr0 = component.__destroy_into_raw();
+    wasm.serializedcomponent_add_component_child(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {string} text
+   */
+  add_text_child(text) {
+    const ptr0 = passStringToWasm0(
+      text,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    wasm.serializedcomponent_add_text_child(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {string}
+   */
+  get component_type() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.serializedcomponent_component_type(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {string} json
+   * @returns {SerializedComponent}
+   */
+  static from_json(json) {
+    const ptr0 = passStringToWasm0(
+      json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.serializedcomponent_from_json(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return SerializedComponent.__wrap(ret[0]);
+  }
+  /**
+   * @param {string} component_type
+   * @param {string | null} [props]
+   */
+  constructor(component_type, props) {
+    const ptr0 = passStringToWasm0(
+      component_type,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(props)
+      ? 0
+      : passStringToWasm0(
+          props,
+          wasm.__wbindgen_malloc,
+          wasm.__wbindgen_realloc,
+        );
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.serializedcomponent_new(ptr0, len0, ptr1, len1);
+    this.__wbg_ptr = ret >>> 0;
+    SerializedComponentFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @returns {string | undefined}
+   */
+  get props() {
+    const ret = wasm.serializedcomponent_props(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
+  /**
+   * @returns {string}
+   */
+  to_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.serializedcomponent_to_json(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose)
+  SerializedComponent.prototype[Symbol.dispose] =
+    SerializedComponent.prototype.free;
+
+/**
+ * Diff result for component tree changes
+ */
+export class TreeDiff {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TreeDiffFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_treediff_free(ptr, 0);
+  }
+  /**
+   * Get the change type
+   * @returns {string}
+   */
+  get change_type() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.treediff_change_type(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {string} path
+   * @param {string} change_type
+   * @param {string | null} [old_value]
+   * @param {string | null} [new_value]
+   */
+  constructor(path, change_type, old_value, new_value) {
+    const ptr0 = passStringToWasm0(
+      path,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      change_type,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(old_value)
+      ? 0
+      : passStringToWasm0(
+          old_value,
+          wasm.__wbindgen_malloc,
+          wasm.__wbindgen_realloc,
+        );
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(new_value)
+      ? 0
+      : passStringToWasm0(
+          new_value,
+          wasm.__wbindgen_malloc,
+          wasm.__wbindgen_realloc,
+        );
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.treediff_new(
+      ptr0,
+      len0,
+      ptr1,
+      len1,
+      ptr2,
+      len2,
+      ptr3,
+      len3,
+    );
+    this.__wbg_ptr = ret >>> 0;
+    TreeDiffFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Get the new value
+   * @returns {string | undefined}
+   */
+  get new_value() {
+    const ret = wasm.treediff_new_value(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
+  /**
+   * Get the old value
+   * @returns {string | undefined}
+   */
+  get old_value() {
+    const ret = wasm.treediff_old_value(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+  }
+  /**
+   * Get the path
+   * @returns {string}
+   */
+  get path() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.treediff_path(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  to_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.treediff_to_json(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose)
+  TreeDiff.prototype[Symbol.dispose] = TreeDiff.prototype.free;
+
+/**
+ * Apply a patch to a component tree
+ * @param {string} tree_json
+ * @param {string} patch_json
+ * @returns {string}
+ */
+export function apply_patch(tree_json, patch_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      patch_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.apply_patch(ptr0, len0, ptr1, len1);
+    deferred3_0 = ret[0];
+    deferred3_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Compute diff between two component trees
+ * @param {string} old_json
+ * @param {string} new_json
+ * @returns {string}
+ */
+export function diff_trees(old_json, new_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      old_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      new_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.diff_trees(ptr0, len0, ptr1, len1);
+    deferred3_0 = ret[0];
+    deferred3_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Walk the component tree and collect CSS classes
+ * @param {string} tree_json
+ * @returns {string}
+ */
+export function extract_css_classes(tree_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extract_css_classes(ptr0, len0);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+
+/**
+ * Generate CSS for collected classes
+ * @param {string} classes_json
+ * @param {string} manifest_json
+ * @returns {string}
+ */
+export function generate_css_for_classes(classes_json, manifest_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      classes_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.generate_css_for_classes(ptr0, len0, ptr1, len1);
+    deferred3_0 = ret[0];
+    deferred3_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Generate minimal hydration script for interactive components
+ * @param {string} interactive_nodes_json
+ * @param {string} env_json
+ * @returns {string}
+ */
+export function generate_hydration_script(interactive_nodes_json, env_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      interactive_nodes_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      env_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.generate_hydration_script(ptr0, len0, ptr1, len1);
+    deferred3_0 = ret[0];
+    deferred3_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Generate skeleton CSS with pulse animation
+ * @returns {string}
+ */
+export function generate_skeleton_css() {
+  let deferred1_0;
+  let deferred1_1;
+  try {
+    const ret = wasm.generate_skeleton_css();
+    deferred1_0 = ret[0];
+    deferred1_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+  }
+}
+
+/**
+ * Get skeleton stats from a tree
+ * @param {string} tree_json
+ * @returns {string}
+ */
+export function get_skeleton_stats(tree_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_skeleton_stats(ptr0, len0);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+
+export function init() {
+  wasm.init();
+}
+
+/**
+ * Full page render: combines tree rendering with CSS, assets, and fonts
+ * @param {string} tree_json
+ * @param {string} css_manifest_json
+ * @param {string} asset_manifest_json
+ * @param {string} font_manifest_json
+ * @param {string} title
+ * @param {string} description
+ * @returns {string}
+ */
+export function render_page(
+  tree_json,
+  css_manifest_json,
+  asset_manifest_json,
+  font_manifest_json,
+  title,
+  description,
+) {
+  let deferred7_0;
+  let deferred7_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      css_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(
+      asset_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(
+      font_manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passStringToWasm0(
+      title,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passStringToWasm0(
+      description,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len5 = WASM_VECTOR_LEN;
+    const ret = wasm.render_page(
+      ptr0,
+      len0,
+      ptr1,
+      len1,
+      ptr2,
+      len2,
+      ptr3,
+      len3,
+      ptr4,
+      len4,
+      ptr5,
+      len5,
+    );
+    deferred7_0 = ret[0];
+    deferred7_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+  }
+}
+
+/**
+ * Render a skeleton tree to HTML
+ * @param {string} tree_json
+ * @returns {string}
+ */
+export function render_skeleton(tree_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.render_skeleton(ptr0, len0);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+
+/**
+ * Render a complete skeleton page (skeleton HTML + CSS)
+ * @param {string} tree_json
+ * @returns {string}
+ */
+export function render_skeleton_page(tree_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.render_skeleton_page(ptr0, len0);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+
+/**
+ * Render a component tree to HTML string
+ * @param {string} tree_json
+ * @returns {string}
+ */
+export function render_tree_to_html(tree_json) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.render_tree_to_html(ptr0, len0);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
+
+/**
+ * Resolve asset references in the tree (replace paths with data URIs)
+ * @param {string} tree_json
+ * @param {string} manifest_json
+ * @returns {string}
+ */
+export function resolve_assets(tree_json, manifest_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(
+      tree_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(
+      manifest_json,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc,
+    );
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.resolve_assets(ptr0, len0, ptr1, len1);
+    deferred3_0 = ret[0];
+    deferred3_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wbindgen_throw_be289d5034ed271b: function (arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_error_7534b8e9a36f1ab4: function (arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+      }
+    },
+    __wbg_new_8a6f238a6ece86ea: function () {
+      const ret = new Error();
+      return ret;
+    },
+    __wbg_stack_0ed75d68575b0f3c: function (arg0, arg1) {
+      const ret = arg1.stack;
+      const ptr1 = passStringToWasm0(
+        ret,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbindgen_cast_0000000000000001: function (arg0, arg1) {
+      // Cast intrinsic for `Ref(String) -> Externref`.
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function () {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, undefined);
+      table.set(offset + 0, undefined);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    },
+  };
+  return {
+    __proto__: null,
+    './aeon_pages_runtime_bg.js': import0,
+  };
+}
+
+const AeonRouterFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_aeonrouter_free(ptr >>> 0, 1),
+      );
+const AssetManifestFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_assetmanifest_free(ptr >>> 0, 1),
+      );
+const CSSManifestFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_cssmanifest_free(ptr >>> 0, 1),
+      );
+const ComponentRegistryFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_componentregistry_free(ptr >>> 0, 1),
+      );
+const FontManifestFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_fontmanifest_free(ptr >>> 0, 1),
+      );
+const RenderContextFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_rendercontext_free(ptr >>> 0, 1),
+      );
+const RouteDefinitionFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_routedefinition_free(ptr >>> 0, 1),
+      );
+const RouteMatchFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_routematch_free(ptr >>> 0, 1),
+      );
+const SerializedComponentFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) =>
+        wasm.__wbg_serializedcomponent_free(ptr >>> 0, 1),
+      );
+const TreeDiffFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_treediff_free(ptr >>> 0, 1));
+
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (
+    cachedDataViewMemory0 === null ||
+    cachedDataViewMemory0.buffer.detached === true ||
+    (cachedDataViewMemory0.buffer.detached === undefined &&
+      cachedDataViewMemory0.buffer !== wasm.memory.buffer)
+  ) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (
+    cachedUint8ArrayMemory0 === null ||
+    cachedUint8ArrayMemory0.byteLength === 0
+  ) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0()
+      .subarray(ptr, ptr + buf.length)
+      .set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr;
+  }
+
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+
+  const mem = getUint8ArrayMemory0();
+
+  let offset = 0;
+
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 0x7f) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true,
+});
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder('utf-8', {
+      ignoreBOM: true,
+      fatal: true,
+    });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(
+    getUint8ArrayMemory0().subarray(ptr, ptr + len),
+  );
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length,
+    };
+  };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  wasmModule = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+
+async function __wbg_load(module, imports) {
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = module.ok && expectedResponseType(module.type);
+
+        if (
+          validResponse &&
+          module.headers.get('Content-Type') !== 'application/wasm'
+        ) {
+          console.warn(
+            '`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n',
+            e,
+          );
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+
+  function expectedResponseType(type) {
+    switch (type) {
+      case 'basic':
+      case 'cors':
+      case 'default':
+        return true;
+    }
+    return false;
+  }
+}
+
+function initSync(module) {
+  if (wasm !== undefined) return wasm;
+
+  if (module !== undefined) {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn(
+        'using deprecated parameters for `initSync()`; pass a single object instead',
+      );
+    }
+  }
+
+  const imports = __wbg_get_imports();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+  if (wasm !== undefined) return wasm;
+
+  if (module_or_path !== undefined) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn(
+        'using deprecated parameters for the initialization function; pass a single object instead',
+      );
+    }
+  }
+
+  if (module_or_path === undefined) {
+    module_or_path = new URL('aeon_pages_runtime_bg.wasm', import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+
+  if (
+    typeof module_or_path === 'string' ||
+    (typeof Request === 'function' && module_or_path instanceof Request) ||
+    (typeof URL === 'function' && module_or_path instanceof URL)
+  ) {
+    module_or_path = fetch(module_or_path);
+  }
+
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+  return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };