piral-blazor 1.0.0-pre.2217 → 1.0.0

package/src/internal/Rendering/RenderBatch/SharedMemoryRenderBatch.ts

@@ -1,137 +0,0 @@
-import { platform } from '../../Environment';
-import {
-  RenderBatch,
-  ArrayRange,
-  ArrayBuilderSegment,
-  RenderTreeDiff,
-  RenderTreeEdit,
-  RenderTreeFrame,
-  ArrayValues,
-  EditType,
-  FrameType,
-  RenderTreeFrameReader,
-} from './RenderBatch';
-import { Pointer, System_Array, System_Object } from '../../Platform/Platform';
-
-// Used when running on Mono WebAssembly for shared-memory interop. The code here encapsulates
-// our knowledge of the memory layout of RenderBatch and all referenced types.
-//
-// In this implementation, all the DTO types are really heap pointers at runtime, hence all
-// the casts to 'any' whenever we pass them to platform.read.
-
-export class SharedMemoryRenderBatch implements RenderBatch {
-  constructor(private batchAddress: Pointer) {}
-
-  // Keep in sync with memory layout in RenderBatch.cs
-  updatedComponents() {
-    return (platform.readStructField<Pointer>(this.batchAddress, 0) as any) as ArrayRange<RenderTreeDiff>;
-  }
-
-  referenceFrames() {
-    return (platform.readStructField<Pointer>(this.batchAddress, arrayRangeReader.structLength) as any) as ArrayRange<
-      RenderTreeDiff
-    >;
-  }
-
-  disposedComponentIds() {
-    return (platform.readStructField<Pointer>(
-      this.batchAddress,
-      arrayRangeReader.structLength * 2,
-    ) as any) as ArrayRange<number>;
-  }
-
-  disposedEventHandlerIds() {
-    return (platform.readStructField<Pointer>(
-      this.batchAddress,
-      arrayRangeReader.structLength * 3,
-    ) as any) as ArrayRange<number>;
-  }
-
-  updatedComponentsEntry(values: ArrayValues<RenderTreeDiff>, index: number) {
-    return arrayValuesEntry(values, index, diffReader.structLength);
-  }
-
-  referenceFramesEntry(values: ArrayValues<RenderTreeFrame>, index: number) {
-    return arrayValuesEntry(values, index, frameReader.structLength);
-  }
-
-  disposedComponentIdsEntry(values: ArrayValues<number>, index: number) {
-    const pointer = arrayValuesEntry(values, index, /* int length */ 4);
-    return platform.readInt32Field((pointer as any) as Pointer);
-  }
-
-  disposedEventHandlerIdsEntry(values: ArrayValues<number>, index: number) {
-    const pointer = arrayValuesEntry(values, index, /* long length */ 8);
-    return platform.readUint64Field((pointer as any) as Pointer);
-  }
-
-  arrayRangeReader = arrayRangeReader;
-
-  arrayBuilderSegmentReader = arrayBuilderSegmentReader;
-
-  diffReader = diffReader;
-
-  editReader = editReader;
-
-  frameReader = frameReader;
-}
-
-// Keep in sync with memory layout in ArrayRange.cs
-const arrayRangeReader = {
-  structLength: 8,
-  values: <T>(arrayRange: ArrayRange<T>) =>
-    (platform.readObjectField<System_Array<T>>(arrayRange as any, 0) as any) as ArrayValues<T>,
-  count: <T>(arrayRange: ArrayRange<T>) => platform.readInt32Field(arrayRange as any, 4),
-};
-
-// Keep in sync with memory layout in ArrayBuilderSegment
-const arrayBuilderSegmentReader = {
-  structLength: 12,
-  values: <T>(arrayBuilderSegment: ArrayBuilderSegment<T>) => {
-    // Evaluate arrayBuilderSegment->_builder->_items, i.e., two dereferences needed
-    const builder = platform.readObjectField<System_Object>(arrayBuilderSegment as any, 0);
-    const builderFieldsAddress = platform.getObjectFieldsBaseAddress(builder);
-    return (platform.readObjectField<System_Array<T>>(builderFieldsAddress, 0) as any) as ArrayValues<T>;
-  },
-  offset: <T>(arrayBuilderSegment: ArrayBuilderSegment<T>) => platform.readInt32Field(arrayBuilderSegment as any, 4),
-  count: <T>(arrayBuilderSegment: ArrayBuilderSegment<T>) => platform.readInt32Field(arrayBuilderSegment as any, 8),
-};
-
-// Keep in sync with memory layout in RenderTreeDiff.cs
-const diffReader = {
-  structLength: 4 + arrayBuilderSegmentReader.structLength,
-  componentId: (diff: RenderTreeDiff) => platform.readInt32Field(diff as any, 0),
-  edits: (diff: RenderTreeDiff) =>
-    (platform.readStructField<Pointer>(diff as any, 4) as any) as ArrayBuilderSegment<RenderTreeEdit>,
-  editsEntry: (values: ArrayValues<RenderTreeEdit>, index: number) =>
-    arrayValuesEntry(values, index, editReader.structLength),
-};
-
-// Keep in sync with memory layout in RenderTreeEdit.cs
-const editReader = {
-  structLength: 20,
-  editType: (edit: RenderTreeEdit) => platform.readInt32Field(edit as any, 0) as EditType,
-  siblingIndex: (edit: RenderTreeEdit) => platform.readInt32Field(edit as any, 4),
-  newTreeIndex: (edit: RenderTreeEdit) => platform.readInt32Field(edit as any, 8),
-  moveToSiblingIndex: (edit: RenderTreeEdit) => platform.readInt32Field(edit as any, 8),
-  removedAttributeName: (edit: RenderTreeEdit) => platform.readStringField(edit as any, 16),
-};
-
-// Keep in sync with memory layout in RenderTreeFrame.cs
-const frameReader = {
-  structLength: 36,
-  frameType: (frame: RenderTreeFrame) => platform.readInt16Field(frame as any, 4) as FrameType,
-  subtreeLength: (frame: RenderTreeFrame) => platform.readInt32Field(frame as any, 8),
-  elementReferenceCaptureId: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 16),
-  componentId: (frame: RenderTreeFrame) => platform.readInt32Field(frame as any, 12),
-  elementName: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 16),
-  textContent: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 16),
-  markupContent: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 16)!,
-  attributeName: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 16),
-  attributeValue: (frame: RenderTreeFrame) => platform.readStringField(frame as any, 24, true),
-  attributeEventHandlerId: (frame: RenderTreeFrame) => platform.readUint64Field(frame as any, 8),
-};
-
-function arrayValuesEntry<T>(arrayValues: ArrayValues<T>, index: number, itemSize: number): T {
-  return (platform.getArrayEntryPtr((arrayValues as any) as System_Array<T>, index, itemSize) as any) as T;
-}

package/src/internal/Rendering/RenderBatch/Utf8Decoder.ts

@@ -1,66 +0,0 @@
-const nativeDecoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-8') : null;
-
-export const decodeUtf8: (bytes: Uint8Array) => string = nativeDecoder
-  ? nativeDecoder.decode.bind(nativeDecoder)
-  : decodeImpl;
-
-/* !
-Logic in decodeImpl is derived from fast-text-encoding
-https://github.com/samthor/fast-text-encoding
-License for fast-text-encoding: Apache 2.0
-https://github.com/samthor/fast-text-encoding/blob/master/LICENSE
-*/
-
-function decodeImpl(bytes: Uint8Array): string {
-  let pos = 0;
-  const len = bytes.length;
-  const out: number[] = [];
-  const substrings: string[] = [];
-
-  while (pos < len) {
-    const byte1 = bytes[pos++];
-    if (byte1 === 0) {
-      break; // NULL
-    }
-
-    if ((byte1 & 0x80) === 0) {
-      // 1-byte
-      out.push(byte1);
-    } else if ((byte1 & 0xe0) === 0xc0) {
-      // 2-byte
-      const byte2 = bytes[pos++] & 0x3f;
-      out.push(((byte1 & 0x1f) << 6) | byte2);
-    } else if ((byte1 & 0xf0) === 0xe0) {
-      const byte2 = bytes[pos++] & 0x3f;
-      const byte3 = bytes[pos++] & 0x3f;
-      out.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
-    } else if ((byte1 & 0xf8) === 0xf0) {
-      const byte2 = bytes[pos++] & 0x3f;
-      const byte3 = bytes[pos++] & 0x3f;
-      const byte4 = bytes[pos++] & 0x3f;
-
-      // this can be > 0xffff, so possibly generate surrogates
-      let codepoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
-      if (codepoint > 0xffff) {
-        // codepoint &= ~0x10000;
-        codepoint -= 0x10000;
-        out.push(((codepoint >>> 10) & 0x3ff) | 0xd800);
-        codepoint = 0xdc00 | (codepoint & 0x3ff);
-      }
-      out.push(codepoint);
-    } else {
-      // FIXME: we're ignoring this
-    }
-
-    // As a workaround for https://github.com/samthor/fast-text-encoding/issues/1,
-    // make sure the 'out' array never gets too long. When it reaches a limit, we
-    // stringify what we have so far and append to a list of outputs.
-    if (out.length > 1024) {
-      substrings.push(String.fromCharCode.apply(null, out));
-      out.length = 0;
-    }
-  }
-
-  substrings.push(String.fromCharCode.apply(null, out));
-  return substrings.join('');
-}

package/src/internal/Rendering/Renderer.ts

@@ -1,98 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-import '../Platform/Platform';
-import '../Environment';
-import { RenderBatch } from './RenderBatch/RenderBatch';
-import { BrowserRenderer } from './BrowserRenderer';
-import { toLogicalElement, LogicalElement } from './LogicalElements';
-
-interface BrowserRendererRegistry {
-  [browserRendererId: number]: BrowserRenderer;
-}
-const browserRenderers: BrowserRendererRegistry = {};
-let shouldResetScrollAfterNextBatch = false;
-
-export function attachRootComponentToLogicalElement(
-  browserRendererId: number,
-  logicalElement: LogicalElement,
-  componentId: number,
-): void {
-  let browserRenderer = browserRenderers[browserRendererId];
-  if (!browserRenderer) {
-    browserRenderer = browserRenderers[browserRendererId] = new BrowserRenderer(browserRendererId);
-  }
-
-  browserRenderer.attachRootComponentToLogicalElement(componentId, logicalElement);
-}
-
-export function attachRootComponentToElement(
-  elementSelector: string,
-  componentId: number,
-  browserRendererId?: number,
-): void {
-  const element = document.querySelector(elementSelector);
-  if (!element) {
-    throw new Error(`Could not find any element matching selector '${elementSelector}'.`);
-  }
-
-  // 'allowExistingContents' to keep any prerendered content until we do the first client-side render
-  // Only client-side Blazor supplies a browser renderer ID
-  attachRootComponentToLogicalElement(
-    browserRendererId || 0,
-    toLogicalElement(element, /* allow existing contents */ true),
-    componentId,
-  );
-}
-
-export function renderBatch(browserRendererId: number, batch: RenderBatch): void {
-  const browserRenderer = browserRenderers[browserRendererId];
-  if (!browserRenderer) {
-    throw new Error(`There is no browser renderer with ID ${browserRendererId}.`);
-  }
-
-  const arrayRangeReader = batch.arrayRangeReader;
-  const updatedComponentsRange = batch.updatedComponents();
-  const updatedComponentsValues = arrayRangeReader.values(updatedComponentsRange);
-  const updatedComponentsLength = arrayRangeReader.count(updatedComponentsRange);
-  const referenceFrames = batch.referenceFrames();
-  const referenceFramesValues = arrayRangeReader.values(referenceFrames);
-  const diffReader = batch.diffReader;
-
-  for (let i = 0; i < updatedComponentsLength; i++) {
-    const diff = batch.updatedComponentsEntry(updatedComponentsValues, i);
-    const componentId = diffReader.componentId(diff);
-    const edits = diffReader.edits(diff);
-    browserRenderer.updateComponent(batch, componentId, edits, referenceFramesValues);
-  }
-
-  const disposedComponentIdsRange = batch.disposedComponentIds();
-  const disposedComponentIdsValues = arrayRangeReader.values(disposedComponentIdsRange);
-  const disposedComponentIdsLength = arrayRangeReader.count(disposedComponentIdsRange);
-  for (let i = 0; i < disposedComponentIdsLength; i++) {
-    const componentId = batch.disposedComponentIdsEntry(disposedComponentIdsValues, i);
-    browserRenderer.disposeComponent(componentId);
-  }
-
-  const disposedEventHandlerIdsRange = batch.disposedEventHandlerIds();
-  const disposedEventHandlerIdsValues = arrayRangeReader.values(disposedEventHandlerIdsRange);
-  const disposedEventHandlerIdsLength = arrayRangeReader.count(disposedEventHandlerIdsRange);
-  for (let i = 0; i < disposedEventHandlerIdsLength; i++) {
-    const eventHandlerId = batch.disposedEventHandlerIdsEntry(disposedEventHandlerIdsValues, i);
-    browserRenderer.disposeEventHandler(eventHandlerId);
-  }
-
-  resetScrollIfNeeded();
-}
-
-export function resetScrollAfterNextBatch() {
-  shouldResetScrollAfterNextBatch = true;
-}
-
-function resetScrollIfNeeded() {
-  if (shouldResetScrollAfterNextBatch) {
-    shouldResetScrollAfterNextBatch = false;
-
-    // This assumes the scroller is on the window itself. There isn't a general way to know
-    // if some other element is playing the role of the primary scroll region.
-    window.scrollTo && window.scrollTo(0, 0);
-  }
-}

package/src/internal/Rendering/RendererEventDispatcher.ts

@@ -1,20 +0,0 @@
-import { EventDescriptor } from './BrowserRenderer';
-import { UIEventArgs } from './EventForDotNet';
-
-type EventDispatcher = (eventDescriptor: EventDescriptor, eventArgs: UIEventArgs) => void;
-
-let eventDispatcherInstance: EventDispatcher;
-
-export function dispatchEvent(eventDescriptor: EventDescriptor, eventArgs: UIEventArgs): void {
-  if (!eventDispatcherInstance) {
-    throw new Error("eventDispatcher not initialized. Call 'setEventDispatcher' to configure it.");
-  }
-
-  return eventDispatcherInstance(eventDescriptor, eventArgs);
-}
-
-export function setEventDispatcher(
-  newDispatcher: (eventDescriptor: EventDescriptor, eventArgs: UIEventArgs) => Promise<void>,
-): void {
-  eventDispatcherInstance = newDispatcher;
-}

package/src/internal/Services/NavigationManager.ts

@@ -1,157 +0,0 @@
-import { EventDelegator } from '../Rendering/EventDelegator';
-
-// tslint:disable:no-string-literal
-// tslint:disable:no-null-keyword
-
-let hasEnabledNavigationInterception = true;
-let hasRegisteredNavigationEventListeners = false;
-
-// Will be initialized once someone registers
-let notifyLocationChangedCallback: ((uri: string, intercepted: boolean) => Promise<void>) | null = null;
-
-// These are the functions we're making available for invocation from .NET
-export const navigationManager = {
-  listenForNavigationEvents,
-  enableNavigationInterception,
-  disableNavigationInterception,
-  navigateTo,
-  getBaseURI: () => document.baseURI,
-  getLocationHref: () => location.href,
-};
-
-function listenForNavigationEvents(callback: (uri: string, intercepted: boolean) => Promise<void>) {
-  notifyLocationChangedCallback = callback;
-
-  if (hasRegisteredNavigationEventListeners) {
-    return;
-  }
-
-  hasRegisteredNavigationEventListeners = true;
-  window.addEventListener('popstate', () => notifyLocationChanged(false));
-}
-
-function disableNavigationInterception() {
-  hasEnabledNavigationInterception = false;
-}
-
-function enableNavigationInterception() {
-  hasEnabledNavigationInterception = true;
-}
-
-export function attachToEventDelegator(eventDelegator: EventDelegator) {
-  // We need to respond to clicks on <a> elements *after* the EventDelegator has finished
-  // running its simulated bubbling process so that we can respect any preventDefault requests.
-  // So instead of registering our own native event, register using the EventDelegator.
-  eventDelegator.notifyAfterClick((event) => {
-    if (!hasEnabledNavigationInterception || !(event.target instanceof HTMLElement)) {
-      return;
-    }
-
-    const anc = event.target.closest('[data-blazor-pilet-root], [data-portal-id]');
-
-    if (!(anc instanceof HTMLElement) || !anc.dataset.blazorPiletRoot) {
-      return;
-    }
-
-    if (event.button !== 0 || eventHasSpecialKey(event)) {
-      // Don't stop ctrl/meta-click (etc) from opening links in new tabs/windows
-      return;
-    }
-
-    if (event.defaultPrevented) {
-      return;
-    }
-
-    // Intercept clicks on all <a> elements where the href is within the <base href> URI space
-    // We must explicitly check if it has an 'href' attribute, because if it doesn't, the result might be null or an empty string depending on the browser
-    const anchorTarget = findClosestAncestor(event.target as Element | null, 'A') as HTMLAnchorElement | null;
-    const hrefAttributeName = 'href';
-
-    if (anchorTarget && anchorTarget.hasAttribute(hrefAttributeName)) {
-      const targetAttributeValue = anchorTarget.getAttribute('target');
-      const opensInSameFrame = !targetAttributeValue || targetAttributeValue === '_self';
-
-      if (!opensInSameFrame) {
-        return;
-      }
-
-      const href = anchorTarget.getAttribute(hrefAttributeName)!;
-      const absoluteHref = toAbsoluteUri(href);
-
-      if (isWithinBaseUriSpace(absoluteHref)) {
-        event.preventDefault();
-        performInternalNavigation(anchorTarget, absoluteHref, true);
-      }
-    }
-  });
-}
-
-export function navigateTo(uri: string, forceLoad: boolean, replace: boolean = false) {
-  const absoluteUri = toAbsoluteUri(uri);
-
-  if (!forceLoad && isWithinBaseUriSpace(absoluteUri)) {
-    // It's an internal URL, so do client-side navigation
-    performInternalNavigation(document.body, absoluteUri, false, replace);
-  } else if (forceLoad && location.href === uri) {
-    // Force-loading the same URL you're already on requires special handling to avoid
-    // triggering browser-specific behavior issues.
-    // For details about what this fixes and why, see https://github.com/dotnet/aspnetcore/pull/10839
-    const temporaryUri = uri + '?';
-    history.replaceState(null, '', temporaryUri);
-    location.replace(uri);
-  } else if (replace) {
-    history.replaceState(null, '', absoluteUri);
-  } else {
-    // It's either an external URL, or forceLoad is requested, so do a full page load
-    location.href = uri;
-  }
-}
-
-function performInternalNavigation(
-  target: HTMLElement,
-  absoluteInternalHref: string,
-  interceptedLink: boolean,
-  replace: boolean = false,
-) {
-  const path = getRelativeUri(absoluteInternalHref);
-  window['Blazor'].emitNavigateEvent(target, path, replace);
-  notifyLocationChanged(interceptedLink);
-}
-
-async function notifyLocationChanged(interceptedLink: boolean) {
-  if (notifyLocationChangedCallback) {
-    await notifyLocationChangedCallback(location.href, interceptedLink);
-  }
-}
-
-let testAnchor: HTMLAnchorElement;
-export function toAbsoluteUri(relativeUri: string) {
-  testAnchor = testAnchor || document.createElement('a');
-  testAnchor.href = relativeUri;
-  return testAnchor.href;
-}
-
-function findClosestAncestor(element: Element | null, tagName: string) {
-  return !element ? null : element.tagName === tagName ? element : findClosestAncestor(element.parentElement, tagName);
-}
-
-function getBaseUri() {
-  // TODO: Might baseURI really be null?
-  return toBaseUriWithTrailingSlash(document.baseURI);
-}
-
-function getRelativeUri(href: string) {
-  return href.substr(getBaseUri().length);
-}
-
-function isWithinBaseUriSpace(href: string) {
-  return href.startsWith(getBaseUri());
-}
-
-function toBaseUriWithTrailingSlash(baseUri: string) {
-  return baseUri.substr(0, baseUri.lastIndexOf('/') + 1);
-}
-
-function eventHasSpecialKey(event: MouseEvent) {
-  return event.ctrlKey || event.shiftKey || event.altKey || event.metaKey;
-}

package/src/internal/globals.ts

@@ -1,5 +0,0 @@
-import '@dotnet/jsinterop';
-
-window['Blazor'] = {
-  _internal: {},
-};

package/src/internal/index.ts

@@ -1,170 +0,0 @@
-import './globals';
-import { setPlatform } from './Environment';
-import { Pointer } from './Platform/Platform';
-import { navigationManager, navigateTo } from './Services/NavigationManager';
-import { BootJsonData, BootConfigResult } from './Platform/BootConfig';
-import { monoPlatform } from './Platform/Mono/MonoPlatform';
-import { WebAssemblyResourceLoader } from './Platform/WebAssemblyResourceLoader';
-import { WebAssemblyConfigLoader } from './Platform/WebAssemblyConfigLoader';
-import { renderBatch } from './Rendering/Renderer';
-import { SharedMemoryRenderBatch } from './Rendering/RenderBatch/SharedMemoryRenderBatch';
-import { attachRootComponentToElement } from './Rendering/Renderer';
-import { setEventDispatcher } from './Rendering/RendererEventDispatcher';
-
-export { BootJsonData };
-
-export const eventNames = {
-  render: 'render-blazor-extension',
-  navigate: 'navigate-blazor',
-};
-
-const coreLib = 'Piral.Blazor.Core';
-const eventParents: Array<HTMLElement> = [];
-
-function isRooted(target: HTMLElement) {
-  let parent = target.parentElement;
-
-  while (parent) {
-    if (parent.id === 'blazor-root') {
-      return true;
-    }
-
-    parent = parent.parentElement;
-  }
-
-  return false;
-}
-
-function findTarget(target: HTMLElement = document.body) {
-  if (eventParents.length === 0) {
-    return target;
-  } else if (target === document.body) {
-    return eventParents[0];
-  } else {
-    return target;
-  }
-}
-
-// tslint:disable:no-string-literal
-
-export function activate(moduleName: string, props: any) {
-  return DotNet.invokeMethodAsync<string>(coreLib, 'Activate', moduleName, props);
-}
-
-export function deactivate(moduleName: string, referenceId: string) {
-  return DotNet.invokeMethodAsync<string>(coreLib, 'Deactivate', moduleName, referenceId);
-}
-
-export function addReference(blob: Blob) {
-  return new Promise((resolve) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      const data = reader.result.toString().replace(/^data:.+;base64,/, '');
-      DotNet.invokeMethodAsync(coreLib, 'LoadComponentsFromLibrary', data).then(resolve);
-    };
-    reader.readAsDataURL(blob);
-  });
-}
-
-export function removeReference(name: string) {
-  return DotNet.invokeMethodAsync(coreLib, 'UnloadComponentsFromLibrary', name);
-}
-
-export function attachEvents(
-  host: HTMLElement,
-  render: (ev: CustomEvent) => void,
-  navigate: (ev: CustomEvent) => void,
-) {
-  eventParents.push(host);
-  host.addEventListener(eventNames.render, render, false);
-  host.addEventListener(eventNames.navigate, navigate, false);
-  return () => {
-    eventParents.splice(eventParents.indexOf(host), 1);
-    host.removeEventListener(eventNames.render, render, false);
-    host.removeEventListener(eventNames.navigate, navigate, false);
-  };
-}
-
-export async function initialize(data: BootJsonData) {
-  data.cacheBootResources = false;
-
-  setEventDispatcher((eventDescriptor, eventArgs) =>
-    DotNet.invokeMethodAsync(
-      'Microsoft.AspNetCore.Components.WebAssembly',
-      'DispatchEvent',
-      eventDescriptor,
-      JSON.stringify(eventArgs),
-    ),
-  );
-
-  // Configure environment for execution under Mono WebAssembly with shared-memory rendering
-  const platform = setPlatform(monoPlatform);
-
-  Object.assign(window['Blazor'], {
-    platform,
-    emitRenderEvent(source: HTMLElement, name: string) {
-      const target = findTarget(source);
-      const eventInit = {
-        bubbles: true,
-        detail: {
-          target,
-          props: {
-            name,
-          },
-        },
-      };
-      const delayEmit = () =>
-        requestAnimationFrame(() => {
-          if (!isRooted(target)) {
-            target.dispatchEvent(new CustomEvent(eventNames.render, eventInit));
-          } else {
-            delayEmit();
-          }
-        });
-      delayEmit();
-    },
-    emitNavigateEvent(source: HTMLElement, to: string, replace = false, state?: any) {
-      findTarget(source).dispatchEvent(
-        new CustomEvent(eventNames.navigate, {
-          bubbles: true,
-          detail: {
-            to,
-            replace,
-            state,
-          },
-        }),
-      );
-    },
-  });
-
-  Object.assign(window['Blazor']._internal, {
-    navigateTo,
-    navigationManager: {
-      ...navigationManager,
-      getUnmarshalledBaseURI: () => BINDING.js_string_to_mono_string(navigationManager.getBaseURI()),
-      getUnmarshalledLocationHref: () => BINDING.js_string_to_mono_string(navigationManager.getLocationHref()),
-    },
-    attachRootComponentToElement,
-    renderBatch(browserRendererId: number, batchAddress: Pointer) {
-      renderBatch(browserRendererId, new SharedMemoryRenderBatch(batchAddress));
-    },
-  });
-
-  const bootConfigResult = new BootConfigResult(data);
-
-  const [resourceLoader] = await Promise.all([
-    WebAssemblyResourceLoader.initAsync(bootConfigResult.bootConfig, {}),
-    WebAssemblyConfigLoader.initAsync(bootConfigResult),
-  ]);
-
-  try {
-    await platform.start(resourceLoader);
-    platform.callEntryPoint(resourceLoader.bootConfig.entryAssembly);
-  } catch (ex) {
-    throw new Error(`Failed to start platform. Reason: ${ex}`);
-  }
-
-  return {
-    platform,
-  };
-}