glass-easel 0.2.0 → 0.3.0

package/src/selector.ts

@@ -1,4 +1,6 @@
-import { Element, Component, VirtualNode, ShadowRoot, ComponentSpace } from '.'
+import { type ComponentSpace } from './component_space'
+import { type Element } from './element'
+import { isComponent, isElement, isShadowRoot, isVirtualNode } from './type_symbol'
 
 const enum SegmentRelation {
   Child,
@@ -106,10 +108,10 @@ export class ParsedSelector {
     do {
       if (!nextNode.parentNode) {
         if (nextRelation === SegmentRelation.CrossShadowDescendant) {
-          nextNode = nextNode instanceof ShadowRoot ? nextNode.getHostNode() : null
+          nextNode = isShadowRoot(nextNode) ? nextNode.getHostNode() : null
         } else if (relation === SegmentRelation.CrossShadowDescendant) {
           match = false
-          nextNode = nextNode instanceof ShadowRoot ? nextNode.getHostNode() : null
+          nextNode = isShadowRoot(nextNode) ? nextNode.getHostNode() : null
         } else {
           nextNode = null
         }
@@ -117,7 +119,7 @@ export class ParsedSelector {
         nextNode = nextNode.parentNode
       }
       if (nextNode === root) nextNode = null
-    } while (nextNode instanceof VirtualNode)
+    } while (isVirtualNode(nextNode))
     if (!nextNode) return false
     if (match) {
       // if matches, try match ancestors
@@ -149,7 +151,7 @@ export class ParsedSelector {
    * otherwise it match in the whole tree.
    */
   testSelector(root: Element | null, node: Element): boolean {
-    if (node instanceof VirtualNode) return false
+    if (isVirtualNode(node)) return false
     const union = this.unions
     let ownerSpace: ComponentSpace | undefined
     if (root !== null) {
@@ -181,7 +183,7 @@ export class ParsedSelector {
         if (findOne) return node
         ret.push(node)
       }
-      if (node instanceof Component) {
+      if (isComponent(node)) {
         const shadowRoot = node.getShadowRoot()
         if (shadowRoot) {
           const r = rec(root, shadowRoot, findOne)
@@ -193,7 +195,7 @@ export class ParsedSelector {
       const children = node.childNodes
       for (let i = 0; i < children.length; i += 1) {
         const child = children[i]
-        if (child instanceof Element) {
+        if (isElement(child)) {
           const r = rec(root, child, findOne)
           if (r && findOne) {
             return r

package/src/shadow_root.ts

@@ -1,20 +1,21 @@
-import * as backend from './backend/backend_protocol'
-import { VirtualNode } from './virtual_node'
+import { BM, BackendMode, type backend } from './backend'
+import { type ComponentDefinitionWithPlaceholder } from './behavior'
 import {
   Component,
-  GeneralComponentDefinition,
-  GeneralComponent,
   convertGenerics,
   resolvePlaceholder,
+  type GeneralComponent,
+  type GeneralComponentDefinition,
 } from './component'
-import { TextNode } from './text_node'
-import { NativeNode } from './native_node'
-import { DoubleLinkedList, Element } from './element'
-import { Node } from './node'
-import { ComponentDefinitionWithPlaceholder } from './behavior'
-import { BM, BackendMode } from './backend/mode'
 import { DeepCopyStrategy, getDeepCopyStrategy } from './data_proxy'
 import { deepCopy, simpleDeepCopy } from './data_utils'
+import { Element, type DoubleLinkedList } from './element'
+import { NativeNode } from './native_node'
+import { type Node } from './node'
+import { TextNode } from './text_node'
+import { SHADOW_ROOT_SYMBOL, isElement, isShadowRoot } from './type_symbol'
+import { VirtualNode } from './virtual_node'
+import { ThirdError, triggerWarning } from './warning'
 
 export const enum SlotMode {
   Direct = 0,
@@ -27,35 +28,32 @@ type AppliedSlotMeta = {
   updatePathTree: { [key: string]: true } | undefined
 }
 
-const wrapPlaceholderCallback = (
-  f: (c: GeneralComponentDefinition) => void,
-  cwp: Exclude<ComponentDefinitionWithPlaceholder, string>,
-  owner: GeneralComponent,
-) => {
-  const waiting = cwp.waiting
-  if (waiting) {
-    waiting.add(f)
-    waiting.hintUsed(owner)
-    return () => {
-      waiting.remove(f)
-    }
-  }
-  return undefined
-}
-
 export class ShadowRoot extends VirtualNode {
+  /* @internal */
+  [SHADOW_ROOT_SYMBOL]: true
+  /* @internal */
   private _$host: GeneralComponent
   /** @internal */
   _$backendShadowRoot: backend.ShadowRootContext | null
+  /* @internal */
   private _$slotMode: SlotMode
+  /* @internal */
   private _$idMap: { [id: string]: Element } | null
+  /* @internal */
   private _$singleSlot?: Element | null
+  /* @internal */
   private _$slots?: Record<string, Element>
+  /* @internal */
   private _$slotsList?: Record<string, DoubleLinkedList<Element>>
+  /* @internal */
   private _$dynamicSlotsInserted?: boolean
+  /* @internal */
   private _$dynamicSlots?: Map<Element, AppliedSlotMeta>
+  /* @internal */
   private _$requiredSlotValueNames?: string[]
+  /* @internal */
   private _$propertyPassingDeepCopy?: DeepCopyStrategy
+  /* @internal */
   private _$insertDynamicSlotHandler?: (
     slots: {
       slot: Element
@@ -63,27 +61,33 @@ export class ShadowRoot extends VirtualNode {
       slotValues: { [name: string]: unknown }
     }[],
   ) => void
+  /* @internal */
   private _$removeDynamicSlotHandler?: (slots: Element[]) => void
+  /* @internal */
   private _$updateDynamicSlotHandler?: (
     slot: Element,
     slotValues: { [name: string]: unknown },
     updatePathTree: { [name: string]: true },
   ) => void
 
+  /* istanbul ignore next */
   constructor() {
     throw new Error('Element cannot be constructed directly')
     // eslint-disable-next-line no-unreachable
-    /* istanbul ignore next */
     super()
   }
 
+  static isShadowRoot = isShadowRoot
+
   static createShadowRoot(host: GeneralComponent): ShadowRoot {
     const node = Object.create(ShadowRoot.prototype) as ShadowRoot
-    const sr =
-      BM.SHADOW || (BM.DYNAMIC && host.getBackendMode() === BackendMode.Shadow)
-        ? (host.getBackendElement() as backend.Element | null)?.getShadowRoot() || null
-        : null
-    node._$initializeVirtual('shadow', node, host._$nodeTreeContext, sr)
+
+    let be: backend.ShadowRootContext | null = null
+    if (BM.SHADOW || (BM.DYNAMIC && host.getBackendMode() === BackendMode.Shadow)) {
+      be = (host._$backendElement as backend.Element).getShadowRoot()!
+    }
+
+    node.is = 'shadow'
     node._$idMap = null
     let slotMode = SlotMode.Single
     const hostComponentOptions = host.getComponentOptions()
@@ -107,10 +111,11 @@ export class ShadowRoot extends VirtualNode {
       node._$removeDynamicSlotHandler = undefined
       node._$updateDynamicSlotHandler = undefined
     }
-    node._$backendShadowRoot = sr
-    node._$initialize(true, sr, node, host._$nodeTreeContext)
+    node._$backendShadowRoot = be
+    node._$initialize(true, be, node, host._$nodeTreeContext)
     node._$host = host
     host.shadowRoot = node
+    be?.associateValue(node)
     return node
   }
 
@@ -133,10 +138,10 @@ export class ShadowRoot extends VirtualNode {
   createNativeNodeWithInit(
     tagName: string,
     stylingName: string,
-    placeholderHandler: (() => void) | undefined,
+    placeholderHandlerRemover: (() => void) | undefined,
     initPropValues?: (comp: NativeNode) => void,
   ): NativeNode {
-    const ret = NativeNode.create(tagName, this, stylingName, placeholderHandler)
+    const ret = NativeNode.create(tagName, this, stylingName, placeholderHandlerRemover)
     initPropValues?.(ret)
     return ret
   }
@@ -160,26 +165,39 @@ export class ShadowRoot extends VirtualNode {
     const space = beh.ownerSpace
     const compName = usingKey === undefined ? tagName : usingKey
 
-    // if the target is in using list, then use the one in using list
-    const using = beh._$using[compName]
-    if (typeof using === 'string') {
-      return this.createNativeNodeWithInit(using, tagName, undefined, initPropValues)
-    }
-    if (using) {
+    const possibleComponentDefinitions = [
+      // if the target is in using list, then use the one in using list
+      beh._$using[compName],
+      // if the target is in generics list, then use the one
+      hostGenericImpls && hostGenericImpls[compName],
+    ]
+
+    for (let i = 0; i < possibleComponentDefinitions.length; i += 1) {
+      const cwp = possibleComponentDefinitions[i]
+      if (cwp === null || cwp === undefined) continue
+      if (typeof cwp === 'string') {
+        return this.createNativeNodeWithInit(cwp, tagName, undefined, initPropValues)
+      }
       let usingTarget: GeneralComponentDefinition | string | undefined
-      if (using.final) {
-        usingTarget = using.final
-      } else if (using.placeholder !== null) {
-        usingTarget = resolvePlaceholder(using.placeholder, space, using.source, hostGenericImpls)
+      let placeholderHandlerRemover: (() => void) | undefined
+      if (cwp.final) {
+        usingTarget = cwp.final
+      } else if (cwp.placeholder !== null) {
+        usingTarget = resolvePlaceholder(cwp.placeholder, space, cwp.source, hostGenericImpls)
+        const waiting = cwp.waiting
+        if (placeholderCallback && waiting) {
+          waiting.add(placeholderCallback)
+          waiting.hintUsed(host)
+          placeholderHandlerRemover = () => {
+            waiting.remove(placeholderCallback)
+          }
+        }
       }
-      const placeholderHandler = placeholderCallback
-        ? wrapPlaceholderCallback(placeholderCallback, using, host)
-        : undefined
       if (typeof usingTarget === 'string') {
         return this.createNativeNodeWithInit(
           usingTarget,
           tagName,
-          placeholderHandler,
+          placeholderHandlerRemover,
           initPropValues,
         )
       }
@@ -190,48 +208,24 @@ export class ShadowRoot extends VirtualNode {
           this,
           null,
           convertGenerics(usingTarget, beh, host, genericTargets),
-          placeholderHandler,
-          initPropValues,
-        )
-      }
-    }
-
-    // if the target is in generics list, then use the one
-    const g = hostGenericImpls && hostGenericImpls[compName]
-    if (typeof g === 'string') {
-      return this.createNativeNodeWithInit(g, tagName, undefined, initPropValues)
-    }
-    if (g) {
-      let genImpl: GeneralComponentDefinition | string | undefined
-      if (g.final) {
-        genImpl = g.final
-      } else if (g.placeholder !== null) {
-        genImpl = resolvePlaceholder(g.placeholder, space, g.source, hostGenericImpls)
-      }
-      const placeholderHandler = placeholderCallback
-        ? wrapPlaceholderCallback(placeholderCallback, g, host)
-        : undefined
-      if (typeof genImpl === 'string') {
-        return this.createNativeNodeWithInit(genImpl, tagName, placeholderHandler, initPropValues)
-      }
-      if (genImpl) {
-        return Component._$advancedCreate(
-          tagName,
-          genImpl,
-          this,
-          null,
-          convertGenerics(genImpl, beh, host, genericTargets),
-          placeholderHandler,
+          placeholderHandlerRemover,
           initPropValues,
         )
       }
     }
 
     // find in the space otherwise
-    const comp = space.getGlobalUsingComponent(compName) ?? space.getDefaultComponent()
-    /* istanbul ignore if */
+    let comp = space.getGlobalUsingComponent(compName)
+    if (comp === null && space._$allowUnusedNativeNode && compName !== '') {
+      comp = compName
+    }
     if (!comp) {
-      throw new Error(`Cannot find component "${compName}"`)
+      comp = space.getDefaultComponent()
+      /* istanbul ignore if */
+      if (!comp) {
+        throw new ThirdError(`Cannot find component "${compName}"`, undefined, this._$host)
+      }
+      triggerWarning(`Cannot find component "${compName}", using default component.`, this._$host)
     }
     if (typeof comp === 'string') {
       return this.createNativeNodeWithInit(comp, tagName, undefined, initPropValues)
@@ -247,6 +241,13 @@ export class ShadowRoot extends VirtualNode {
     )
   }
 
+  createComponentByDef(
+    tagName: string,
+    componentDef: GeneralComponentDefinition,
+  ): GeneralComponent {
+    return Component._$advancedCreate(tagName, componentDef, this, null, null, undefined)
+  }
+
   /**
    * Create a component if the given tag name is a component in the space, or a native node if not
    *
@@ -280,10 +281,13 @@ export class ShadowRoot extends VirtualNode {
       )
     }
 
-    // use native node otherwise
-    const node = NativeNode.create(tagName, this)
-    initPropValues?.(node)
-    return node
+    if (space._$allowUnusedNativeNode) {
+      // use native node otherwise
+      const node = NativeNode.create(tagName, this)
+      initPropValues?.(node)
+      return node
+    }
+    throw new ThirdError(`Unknown tag name ${tagName}`, '[render]', host)
   }
 
   /**
@@ -372,7 +376,7 @@ export class ShadowRoot extends VirtualNode {
     }
     if (slotMode === SlotMode.Multiple) {
       let name: string
-      if (elem instanceof Element) {
+      if (isElement(elem)) {
         name = elem._$nodeSlot
       } else {
         name = ''
@@ -833,154 +837,6 @@ export class ShadowRoot extends VirtualNode {
   getSlotMode(): SlotMode {
     return this._$slotMode
   }
-
-  /** @internal */
-  static _$updateSubtreeSlotNodes(
-    parentNode: Element,
-    elements: Node[],
-    shadowRoot: ShadowRoot | null,
-    oldShadowRoot: ShadowRoot | null,
-    posIndex: number,
-  ):
-    | { updateContainingSlot: () => void; removeSlotNodes: () => void; insertSlotNodes: () => void }
-    | undefined {
-    if (!shadowRoot && !oldShadowRoot) return undefined
-
-    const slotMode = shadowRoot?.getSlotMode()
-    const oldSlotMode = oldShadowRoot?.getSlotMode()
-
-    if (
-      (slotMode === undefined || slotMode === SlotMode.Direct) &&
-      (oldSlotMode === undefined || oldSlotMode === SlotMode.Direct)
-    ) {
-      return undefined
-    }
-
-    if (
-      (slotMode === undefined || slotMode === SlotMode.Single) &&
-      (oldSlotMode === undefined || oldSlotMode === SlotMode.Single)
-    ) {
-      let removeStart = -1
-      let removeCount = 0
-      let insertPos = -1
-      const slotNodesToUpdate: Node[] = []
-      const oldContainingSlot = elements[0]!.containingSlot
-      const containingSlot = shadowRoot?.getContainingSlot(elements[0]!)
-
-      for (let i = 0; i < elements.length; i += 1) {
-        const elem = elements[i]!
-        // eslint-disable-next-line no-loop-func
-        Element.forEachNodeInSlot(elem, (node) => {
-          if (oldContainingSlot) {
-            if (removeCount) {
-              removeCount += 1
-            } else {
-              removeStart = node.slotIndex!
-              removeCount = 1
-            }
-          }
-
-          slotNodesToUpdate.push(node)
-        })
-      }
-
-      if (containingSlot && slotNodesToUpdate.length) {
-        const firstSlotNode = slotNodesToUpdate[0]!
-        insertPos = Element._$findSlotNodeInsertPosition(containingSlot, firstSlotNode, posIndex)
-      }
-
-      return {
-        updateContainingSlot: () => {
-          for (let i = slotNodesToUpdate.length - 1; i >= 0; i -= 1) {
-            const node = slotNodesToUpdate[i]!
-            Element._$updateContainingSlot(node, containingSlot)
-          }
-        },
-        removeSlotNodes: () => {
-          if (oldShadowRoot && oldContainingSlot && removeCount) {
-            Element._$spliceSlotNodes(oldContainingSlot, removeStart, removeCount, undefined)
-          }
-        },
-        insertSlotNodes: () => {
-          if (shadowRoot && containingSlot && slotNodesToUpdate.length) {
-            Element._$spliceSlotNodes(containingSlot, insertPos, 0, slotNodesToUpdate)
-          }
-        },
-      }
-    }
-    const slotNodesToInsertMap = new Map<Element, { nodes: Node[]; insertPos: number }>()
-    const slotNodesToRemoveMap = new Map<Element, { start: number; count: number }>()
-
-    const slotNodesWithContainingSlot: [Node, Element | undefined | null][] = []
-
-    for (let i = 0; i < elements.length; i += 1) {
-      const elem = elements[i]!
-      Element.forEachNodeInSlot(elem, (node, oldContainingSlot) => {
-        const containingSlot =
-          slotMode !== SlotMode.Direct ? shadowRoot?.getContainingSlot(node) : undefined
-
-        if (oldContainingSlot) {
-          const slotNodesToRemove = slotNodesToRemoveMap.get(oldContainingSlot)
-          if (slotNodesToRemove) {
-            slotNodesToRemove.count += 1
-          } else {
-            slotNodesToRemoveMap.set(oldContainingSlot, { start: node.slotIndex!, count: 1 })
-          }
-        }
-
-        if (containingSlot) {
-          const slotNodesToInsert = slotNodesToInsertMap.get(containingSlot)
-          if (slotNodesToInsert) {
-            slotNodesToInsert.nodes.push(node)
-          } else {
-            slotNodesToInsertMap.set(containingSlot, { nodes: [node], insertPos: -1 })
-          }
-        }
-
-        slotNodesWithContainingSlot.push([node, containingSlot])
-      })
-    }
-
-    if (shadowRoot && slotNodesToInsertMap.size) {
-      const iter = slotNodesToInsertMap.entries()
-
-      for (let it = iter.next(); !it.done; it = iter.next()) {
-        const [slot, { nodes: slotNodesToInsert }] = it.value
-        const firstSlotNodeToInsert = slotNodesToInsert[0]!
-        it.value[1].insertPos = Element._$findSlotNodeInsertPosition(
-          slot,
-          firstSlotNodeToInsert,
-          posIndex,
-        )
-      }
-    }
-
-    return {
-      updateContainingSlot: () => {
-        for (let i = slotNodesWithContainingSlot.length - 1; i >= 0; i -= 1) {
-          const [node, containingSlot] = slotNodesWithContainingSlot[i]!
-          Element._$updateContainingSlot(node, containingSlot)
-        }
-      },
-      removeSlotNodes: () => {
-        if (oldShadowRoot && slotNodesToRemoveMap.size) {
-          const iter = slotNodesToRemoveMap.entries()
-          for (let it = iter.next(); !it.done; it = iter.next()) {
-            const [slot, { start, count }] = it.value
-            Element._$spliceSlotNodes(slot, start, count, undefined)
-          }
-        }
-      },
-      insertSlotNodes: () => {
-        if (shadowRoot && slotNodesToInsertMap.size) {
-          const iter = slotNodesToInsertMap.entries()
-
-          for (let it = iter.next(); !it.done; it = iter.next()) {
-            const [slot, { nodes: slotNodesToInsert, insertPos }] = it.value
-            Element._$spliceSlotNodes(slot, insertPos, 0, slotNodesToInsert)
-          }
-        }
-      },
-    }
-  }
 }
+
+ShadowRoot.prototype[SHADOW_ROOT_SYMBOL] = true

package/src/template_engine.ts

@@ -1,9 +1,9 @@
-import { GeneralBehavior } from './behavior'
-import { ShadowRoot } from './shadow_root'
-import { DataChange, DataValue } from './data_proxy'
-import { NormalizedComponentOptions } from './global_options'
-import { ExternalShadowRoot } from './external_shadow_tree'
-import { GeneralComponent } from './component'
+import { type GeneralBehavior } from './behavior'
+import { type ShadowRoot } from './shadow_root'
+import { type DataChange, type DataValue } from './data_proxy'
+import { type NormalizedComponentOptions } from './global_options'
+import { type ExternalShadowRoot } from './external_shadow_tree'
+import { type GeneralComponent } from './component'
 
 /**
  * A template engine that handles the template part of a component
@@ -26,7 +26,10 @@ export interface Template {
   /**
    * Create a template instance for a component instance
    */
-  createInstance(elem: GeneralComponent): TemplateInstance
+  createInstance(
+    elem: GeneralComponent,
+    createShadowRoot: (component: GeneralComponent) => ShadowRoot,
+  ): TemplateInstance
 
   /**
    * Update the content of the template (optional)

package/src/text_node.ts

@@ -1,14 +1,25 @@
-import * as backend from './backend/backend_protocol'
-import * as composedBackend from './backend/composed_backend_protocol'
-import * as domlikeBackend from './backend/domlike_backend_protocol'
-import { ShadowRoot } from './shadow_root'
-import { Element } from './element'
+import {
+  BM,
+  BackendMode,
+  type GeneralBackendElement,
+  type backend,
+  type composedBackend,
+  type domlikeBackend,
+} from './backend'
+import { type Element } from './element'
+import { ENV } from './global_options'
+import { performanceMeasureEnd, performanceMeasureStart } from './devtool'
 import { MutationObserverTarget } from './mutation_observer'
-import { GeneralBackendElement, NodeCast } from './node'
-import { BM, BackendMode } from './backend/mode'
+import { type NodeCast } from './node'
+import { type ShadowRoot } from './shadow_root'
+import { TEXT_NODE_SYMBOL, isTextNode } from './type_symbol'
 
 export class TextNode implements NodeCast {
+  /* @internal */
+  [TEXT_NODE_SYMBOL]!: true
+  /* @internal */
   _$backendElement: GeneralBackendElement | null
+  /* @internal */
   private _$text: string
   ownerShadowRoot: ShadowRoot
   parentNode: Element | null
@@ -31,18 +42,21 @@ export class TextNode implements NodeCast {
 
   constructor(text: string, owner: ShadowRoot) {
     this._$text = String(text)
-    let backendElement: GeneralBackendElement | null
-    if (BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike)) {
-      backendElement = (owner._$nodeTreeContext as domlikeBackend.Context).document.createTextNode(
-        text,
-      )
-    } else if (BM.SHADOW || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Shadow)) {
-      const backend = owner._$backendShadowRoot
-      backendElement = backend?.createTextNode(text) || null
-    } else {
-      const backend = owner._$nodeTreeContext as composedBackend.Context
-      backendElement = backend.createTextNode(text)
+    let backendElement: GeneralBackendElement | null = null
+    const context = owner.getBackendContext()
+    if (context) {
+      if (ENV.DEV) performanceMeasureStart('backend.createTextNode')
+      if (BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike)) {
+        backendElement = (context as domlikeBackend.Context).document.createTextNode(text)
+      } else if (BM.SHADOW || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Shadow)) {
+        const backend = owner._$backendShadowRoot!
+        backendElement = backend.createTextNode(text)
+      } else {
+        const backend = context as composedBackend.Context
+        backendElement = backend.createTextNode(text)
+      }
     }
+    if (ENV.DEV) performanceMeasureEnd()
     this._$backendElement = backendElement
     this.ownerShadowRoot = owner
     this.parentNode = null
@@ -50,6 +64,8 @@ export class TextNode implements NodeCast {
     this.containingSlot = undefined
   }
 
+  static isTextNode = isTextNode
+
   static create(text: string, ownerShadowRoot: ShadowRoot): TextNode {
     return new TextNode(text, ownerShadowRoot)
   }
@@ -87,7 +103,9 @@ export class TextNode implements NodeCast {
           (BM.DYNAMIC && this.ownerShadowRoot.getBackendMode() === BackendMode.Domlike)
         )
       ) {
+        if (ENV.DEV) performanceMeasureStart('backend.release')
         ;(this._$backendElement as backend.Element | composedBackend.Element).release()
+        if (ENV.DEV) performanceMeasureEnd()
       }
       this._$backendElement = null
     }
@@ -122,8 +140,11 @@ export class TextNode implements NodeCast {
   }
 
   set textContent(text: string) {
-    this._$text = String(text)
+    const newText = String(text)
+    if (newText === this._$text) return
+    this._$text = newText
     if (this._$backendElement) {
+      if (ENV.DEV) performanceMeasureStart('backend.setText')
       if (
         BM.DOMLIKE ||
         (BM.DYNAMIC && this.ownerShadowRoot.getBackendMode() === BackendMode.Domlike)
@@ -132,6 +153,7 @@ export class TextNode implements NodeCast {
       } else {
         ;(this._$backendElement as backend.Element | composedBackend.Element).setText(this._$text)
       }
+      if (ENV.DEV) performanceMeasureEnd()
     }
     MutationObserverTarget.callTextObservers(this, {
       type: 'characterData',
@@ -139,3 +161,5 @@ export class TextNode implements NodeCast {
     })
   }
 }
+
+TextNode.prototype[TEXT_NODE_SYMBOL] = true