{
const pattern = /["'<]/g
let m: RegExpExecArray | null
- while ((m = pattern.exec(name)) !== null) {
+ while ((m = pattern.exec(name))) {
emitError(
context,
ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
}
const unexpectedChars = /["'<=`]/g
let m: RegExpExecArray | null
- while ((m = unexpectedChars.exec(match[0])) !== null) {
+ while ((m = unexpectedChars.exec(match[0]))) {
emitError(
context,
ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
export const ITERATE_KEY = Symbol('iterate')
export function isEffect(fn: any): fn is ReactiveEffect {
- return fn != null && fn._isEffect === true
+ return fn && fn._isEffect === true
}
export function effect<T = any>(
scheduler = invoke
} else if (flush === 'pre') {
scheduler = job => {
- if (!instance || instance.vnode.el != null) {
+ if (!instance || instance.isMounted) {
queueJob(job)
} else {
// with 'pre' option, the first call must happen before
rawProps: Data | null,
_options: ComponentPropsOptions | void
) {
- const hasDeclaredProps = _options != null
+ const hasDeclaredProps = !!_options
if (!rawProps && !hasDeclaredProps) {
return
}
// allow mutation of propsProxy (which is readonly by default)
unlock()
- if (rawProps != null) {
+ if (rawProps) {
for (const key in rawProps) {
const value = rawProps[key]
// key, ref are reserved and never passed down
// in case of dynamic props, check if we need to delete keys from
// the props proxy
const { patchFlag } = instance.vnode
- if (
- propsProxy !== null &&
- (patchFlag === 0 || patchFlag & PatchFlags.FULL_PROPS)
- ) {
+ if (propsProxy && (patchFlag === 0 || patchFlag & PatchFlags.FULL_PROPS)) {
const rawInitialProps = toRaw(propsProxy)
for (const key in rawInitialProps) {
if (!hasOwn(props, key)) {
const opt = raw[key]
const prop: NormalizedProp = (options[normalizedKey] =
isArray(opt) || isFunction(opt) ? { type: opt } : opt)
- if (prop != null) {
+ if (prop) {
const booleanIndex = getTypeIndex(Boolean, prop.type)
const stringIndex = getTypeIndex(String, prop.type)
prop[BooleanFlags.shouldCast] = booleanIndex > -1
} else if (renderContext !== EMPTY_OBJ && hasOwn(renderContext, key)) {
accessCache![key] = AccessTypes.CONTEXT
return renderContext[key]
- } else if (type.props != null) {
+ } else if (type.props) {
// only cache other properties when instance has declared (this stable)
// props
if (hasOwn(props, key)) {
// public $xxx properties & user-attached properties (sink)
const publicGetter = publicPropertiesMap[key]
let cssModule
- if (publicGetter != null) {
+ if (publicGetter) {
if (__DEV__ && key === '$attrs') {
markAttrsAccessed()
}
return publicGetter(target)
} else if (
__BUNDLER__ &&
- (cssModule = type.__cssModules) != null &&
+ (cssModule = type.__cssModules) &&
(cssModule = cssModule[key])
) {
return cssModule
} else if (hasOwn(sink, key)) {
return sink[key]
- } else if (__DEV__ && currentRenderingInstance != null) {
+ } else if (__DEV__ && currentRenderingInstance) {
warn(
`Property ${JSON.stringify(key)} was accessed during render ` +
`but is not defined on instance.`
accessCache![key] !== undefined ||
(data !== EMPTY_OBJ && hasOwn(data, key)) ||
hasOwn(renderContext, key) ||
- (type.props != null && hasOwn(type.props, key)) ||
+ (type.props && hasOwn(type.props, key)) ||
hasOwn(publicPropertiesMap, key) ||
hasOwn(sink, key)
)
result = cloneVNode(result, fallthroughAttrs)
// If the child root node is a compiler optimized vnode, make sure it
// force update full props to account for the merged attrs.
- if (result.dynamicChildren !== null) {
+ if (result.dynamicChildren) {
result.patchFlag |= PatchFlags.FULL_PROPS
}
} else if (__DEV__ && !accessedAttrs && result.type !== Comment) {
result = cloneVNode(result, { [parentScopeId]: '' })
}
// inherit directives
- if (vnode.dirs != null) {
+ if (vnode.dirs) {
if (__DEV__ && !isElementRoot(result)) {
warn(
`Runtime directive used on component with non-element root node. ` +
result.dirs = vnode.dirs
}
// inherit transition data
- if (vnode.transition != null) {
+ if (vnode.transition) {
if (__DEV__ && !isElementRoot(result)) {
warn(
`Component inside <Transition> renders non-element root node ` +
}
// force child update on runtime directive usage on component vnode.
- if (nextVNode.dirs != null) {
+ if (nextVNode.dirs) {
return true
}
} else if (!optimized) {
// this path is only taken by manually written render functions
// so presence of any children leads to a forced update
- if (prevChildren != null || nextChildren != null) {
- if (nextChildren == null || !(nextChildren as any).$stable) {
+ if (prevChildren || nextChildren) {
+ if (!nextChildren || !(nextChildren as any).$stable) {
return true
}
}
if (prevProps === nextProps) {
return false
}
- if (prevProps === null) {
- return nextProps !== null
+ if (!prevProps) {
+ return !!nextProps
}
- if (nextProps === null) {
+ if (!nextProps) {
return true
}
return hasPropsChanged(prevProps, nextProps)
ctx: ComponentInternalInstance | null | undefined
): Slot =>
withCtx((props: any) => {
- if (__DEV__ && currentInstance != null) {
+ if (__DEV__ && currentInstance) {
warn(
`Slot "${key}" invoked outside of the render function: ` +
`this will not track dependencies used in the slot. ` +
}
}
}
- } else if (children !== null) {
+ } else if (children) {
// non slot object children (direct value) passed to a component
if (__DEV__ && !isKeepAlive(instance.vnode)) {
warn(
queuePostRenderEffect(() => {
const component = vnode.component!
component.isDeactivated = false
- if (component.a !== null) {
+ if (component.a) {
invokeHooks(component.a)
}
}, parentSuspense)
move(vnode, storageContainer, null, MoveType.LEAVE, parentSuspense)
queuePostRenderEffect(() => {
const component = vnode.component!
- if (component.da !== null) {
+ if (component.da) {
invokeHooks(component.da)
}
component.isDeactivated = true
const target = (n2.target = isString(targetSelector)
? querySelector!(targetSelector)
: targetSelector)
- if (target != null) {
+ if (target) {
if (shapeFlag & ShapeFlags.TEXT_CHILDREN) {
setElementText(target, children as string)
} else if (shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
const nextTarget = (n2.target = isString(targetSelector)
? querySelector!(targetSelector)
: targetSelector)
- if (nextTarget != null) {
+ if (nextTarget) {
// move content
if (shapeFlag & ShapeFlags.TEXT_CHILDREN) {
setElementText(target, '')
fn: Function | Function[],
suspense: SuspenseBoundary | null
): void {
- if (suspense !== null && !suspense.isResolved) {
+ if (suspense && !suspense.isResolved) {
if (isArray(fn)) {
suspense.effects.push(...fn)
} else {
): any[] {
if (isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args)
- if (res != null && !res._isVue && isPromise(res)) {
+ if (res && !res._isVue && isPromise(res)) {
res.catch(err => {
handleError(err, instance, type)
})
const errorInfo = __DEV__ ? ErrorTypeStrings[type] : type
while (cur) {
const errorCapturedHooks = cur.ec
- if (errorCapturedHooks !== null) {
+ if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {
return
parentSuspense: SuspenseBoundary | null,
optimized: boolean
) => {
- optimized = optimized || vnode.dynamicChildren !== null
+ optimized = optimized || !!vnode.dynamicChildren
const { props, patchFlag, shapeFlag, dirs } = vnode
// skip props & children if this is hoisted static nodes
if (patchFlag !== PatchFlags.HOISTED) {
// props
- if (props !== null) {
+ if (props) {
if (
!optimized ||
(patchFlag & PatchFlags.FULL_PROPS ||
patchProp(el, key, null, props[key])
}
}
- } else if (props.onClick != null) {
+ } else if (props.onClick) {
// Fast path for click listeners (which is most often) to avoid
// iterating through props.
patchProp(el, 'onClick', null, props.onClick)
}
// vnode / directive hooks
let vnodeHooks: VNodeHook | null | undefined
- if ((vnodeHooks = props && props.onVnodeBeforeMount) != null) {
+ if ((vnodeHooks = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode)
}
- if (dirs != null) {
+ if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount')
}
- if (
- (vnodeHooks = props && props.onVnodeMounted) != null ||
- dirs != null
- ) {
+ if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode)
dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted')
if (
shapeFlag & ShapeFlags.ARRAY_CHILDREN &&
// skip if element has innerHTML / textContent
- !(props !== null && (props.innerHTML || props.textContent))
+ !(props && (props.innerHTML || props.textContent))
) {
let next = hydrateChildren(
el.firstChild,
parentSuspense: SuspenseBoundary | null,
optimized: boolean
): Node | null => {
- optimized = optimized || vnode.dynamicChildren !== null
+ optimized = optimized || !!vnode.dynamicChildren
const children = vnode.children as VNode[]
const l = children.length
let hasWarned = false
const target = (vnode.target = isString(targetSelector)
? document.querySelector(targetSelector)
: targetSelector)
- if (target != null && vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+ if (target && vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
hydrateChildren(
target.firstChild,
vnode,
optimized = false
) => {
// patching & not same type, unmount old tree
- if (n1 != null && !isSameVNodeType(n1, n2)) {
+ if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1)
unmount(n1, parentComponent, parentSuspense, true)
n1 = null
anchor: HostNode | null,
isSVG: boolean
) => {
- if (n2.el != null && hostCloneNode !== undefined) {
+ if (n2.el && hostCloneNode !== undefined) {
hostInsert(hostCloneNode(n2.el), container, anchor)
} else {
// static nodes are only present when used with compiler-dom/runtime-dom
} else {
patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized)
}
- if (n2.ref !== null && parentComponent !== null) {
+ if (n2.ref != null && parentComponent) {
setRef(n2.ref, n1 && n1.ref, parentComponent, n2.el)
}
}
dirs
} = vnode
if (
- vnode.el !== null &&
+ vnode.el &&
hostCloneNode !== undefined &&
patchFlag === PatchFlags.HOISTED
) {
} else {
el = vnode.el = hostCreateElement(vnode.type as string, isSVG)
// props
- if (props != null) {
+ if (props) {
for (const key in props) {
if (!isReservedProp(key)) {
hostPatchProp(el, key, null, props[key], isSVG)
}
}
- if ((vnodeHook = props.onVnodeBeforeMount) != null) {
+ if ((vnodeHook = props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode)
}
}
- if (dirs != null) {
+ if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount')
}
// scopeId
if (__BUNDLER__) {
- if (scopeId !== null) {
+ if (scopeId) {
hostSetScopeId(el, scopeId)
}
const treeOwnerId = parentComponent && parentComponent.type.__scopeId
// vnode's own scopeId and the current patched component's scopeId is
// different - this is a slot content node.
- if (treeOwnerId != null && treeOwnerId !== scopeId) {
+ if (treeOwnerId && treeOwnerId !== scopeId) {
hostSetScopeId(el, treeOwnerId + '-s')
}
}
parentComponent,
parentSuspense,
isSVG && type !== 'foreignObject',
- optimized || vnode.dynamicChildren !== null
+ optimized || !!vnode.dynamicChildren
)
}
- if (transition != null && !transition.persisted) {
+ if (transition && !transition.persisted) {
transition.beforeEnter(el)
}
}
hostInsert(el, container, anchor)
if (
- (vnodeHook = props && props.onVnodeMounted) != null ||
- (transition != null && !transition.persisted) ||
- dirs != null
+ (vnodeHook = props && props.onVnodeMounted) ||
+ (transition && !transition.persisted) ||
+ dirs
) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode)
const newProps = n2.props || EMPTY_OBJ
let vnodeHook: VNodeHook | undefined | null
- if ((vnodeHook = newProps.onVnodeBeforeUpdate) != null) {
+ if ((vnodeHook = newProps.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1)
}
- if (dirs != null) {
+ if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate')
}
}
const areChildrenSVG = isSVG && n2.type !== 'foreignObject'
- if (dynamicChildren != null) {
+ if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren!,
dynamicChildren,
)
}
- if ((vnodeHook = newProps.onVnodeUpdated) != null || dirs != null) {
+ if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1)
dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated')
optimized
)
} else {
- if (patchFlag & PatchFlags.STABLE_FRAGMENT && dynamicChildren != null) {
+ if (patchFlag & PatchFlags.STABLE_FRAGMENT && dynamicChildren) {
// a stable fragment (template root or <template v-for>) doesn't need to
// patch children order, but it may contain dynamicChildren.
patchBlockChildren(
n2.el = n1.el
}
}
- if (n2.ref !== null && parentComponent !== null) {
+ if (n2.ref != null && parentComponent) {
if (__DEV__ && !(n2.shapeFlag & ShapeFlags.STATEFUL_COMPONENT)) {
pushWarningContext(n2)
warn(
parentComponent
))
- if (__HMR__ && instance.type.__hmrId != null) {
+ if (__HMR__ && instance.type.__hmrId) {
registerHMR(instance)
}
const { bm, m, a, parent } = instance
const subTree = (instance.subTree = renderComponentRoot(instance))
// beforeMount hook
- if (bm !== null) {
+ if (bm) {
invokeHooks(bm)
}
// onVnodeBeforeMount
- if ((vnodeHook = props && props.onVnodeBeforeMount) != null) {
+ if ((vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode)
}
if (el && hydrateNode) {
initialVNode.el = subTree.el
}
// mounted hook
- if (m !== null) {
+ if (m) {
queuePostRenderEffect(m, parentSuspense)
}
// onVnodeMounted
- if ((vnodeHook = props && props.onVnodeMounted) != null) {
+ if ((vnodeHook = props && props.onVnodeMounted)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook!, parent, initialVNode)
}, parentSuspense)
}
// activated hook for keep-alive roots.
if (
- a !== null &&
+ a &&
initialVNode.shapeFlag & ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE
) {
queuePostRenderEffect(a, parentSuspense)
pushWarningContext(next || instance.vnode)
}
- if (next !== null) {
+ if (next) {
updateComponentPreRender(instance, next)
} else {
next = vnode
instance.subTree = nextTree
next.el = vnode.el
// beforeUpdate hook
- if (bu !== null) {
+ if (bu) {
invokeHooks(bu)
}
// onVnodeBeforeUpdate
- if (
- (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) != null
- ) {
+ if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parent, next, vnode)
}
// reset refs
updateHOCHostEl(instance, nextTree.el)
}
// updated hook
- if (u !== null) {
+ if (u) {
queuePostRenderEffect(u, parentSuspense)
}
// onVnodeUpdated
- if ((vnodeHook = next.props && next.props.onVnodeUpdated) != null) {
+ if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook!, parent, next!, vnode)
}, parentSuspense)
const needTransition =
type !== MoveType.REORDER &&
shapeFlag & ShapeFlags.ELEMENT &&
- transition != null
+ transition
if (needTransition) {
if (type === MoveType.ENTER) {
transition!.beforeEnter(el!)
doRemove = false
) => {
const { props, ref, children, dynamicChildren, shapeFlag, dirs } = vnode
- const shouldInvokeDirs = dirs != null && shapeFlag & ShapeFlags.ELEMENT
+ const shouldInvokeDirs = shapeFlag & ShapeFlags.ELEMENT && dirs
let vnodeHook: VNodeHook | undefined | null
// unset ref
- if (ref !== null && parentComponent !== null) {
+ if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, null)
}
- if ((vnodeHook = props && props.onVnodeBeforeUnmount) != null) {
+ if ((vnodeHook = props && props.onVnodeBeforeUnmount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode)
}
invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount')
}
- if (dynamicChildren != null) {
+ if (dynamicChildren) {
// fast path for block nodes: only need to unmount dynamic children.
unmountChildren(dynamicChildren, parentComponent, parentSuspense)
} else if (shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
}
}
- if (
- (vnodeHook = props && props.onVnodeUnmounted) != null ||
- shouldInvokeDirs
- ) {
+ if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode)
shouldInvokeDirs &&
const performRemove = () => {
hostRemove(el!)
- if (
- transition != null &&
- !transition.persisted &&
- transition.afterLeave
- ) {
+ if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave()
}
}
if (
vnode.shapeFlag & ShapeFlags.ELEMENT &&
- transition != null &&
+ transition &&
!transition.persisted
) {
const { leave, delayLeave } = transition
parentSuspense: HostSuspenseBoundary | null,
doRemove?: boolean
) => {
- if (__HMR__ && instance.type.__hmrId != null) {
+ if (__HMR__ && instance.type.__hmrId) {
unregisterHMR(instance)
}
const { bum, effects, update, subTree, um, da, isDeactivated } = instance
// beforeUnmount hook
- if (bum !== null) {
+ if (bum) {
invokeHooks(bum)
}
- if (effects !== null) {
+ if (effects) {
for (let i = 0; i < effects.length; i++) {
stop(effects[i])
}
}
// update may be null if a component is unmounted before its async
// setup has resolved.
- if (update !== null) {
+ if (update) {
stop(update)
unmount(subTree, instance, parentSuspense, doRemove)
}
// unmounted hook
- if (um !== null) {
+ if (um) {
queuePostRenderEffect(um, parentSuspense)
}
// deactivated hook
if (
- da !== null &&
+ da &&
!isDeactivated &&
instance.vnode.shapeFlag & ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE
) {
// cause the suspense to resolve immediately if that was the last dep.
if (
__FEATURE_SUSPENSE__ &&
- parentSuspense !== null &&
+ parentSuspense &&
!parentSuspense.isResolved &&
!parentSuspense.isUnmounted &&
- instance.asyncDep !== null &&
+ instance.asyncDep &&
!instance.asyncResolved
) {
parentSuspense.deps--
const renderContext = toRaw(owner.renderContext)
// unset old ref
- if (oldRef !== null && oldRef !== ref) {
+ if (oldRef != null && oldRef !== ref) {
if (isString(oldRef)) {
refs[oldRef] = null
const oldSetupRef = renderContext[oldRef]
currentBlock = blockStack[blockStack.length - 1] || null
// a block is always going to be patched, so track it as a child of its
// parent block
- if (currentBlock !== null) {
+ if (currentBlock) {
currentBlock.push(vnode)
}
return vnode
}
// class & style normalization.
- if (props !== null) {
+ if (props) {
// for reactive or proxy objects, we need to clone it to enable mutation.
if (isReactive(props) || SetupProxySymbol in props) {
props = extend({}, props)
}
let { class: klass, style } = props
- if (klass != null && !isString(klass)) {
+ if (klass && !isString(klass)) {
props.class = normalizeClass(klass)
}
if (isObject(style)) {
_isVNode: true,
type,
props,
- key: props !== null && props.key !== undefined ? props.key : null,
+ key: props && props.key !== undefined ? props.key : null,
ref:
- props !== null && props.ref !== undefined
+ props && props.ref !== undefined
? [currentRenderingInstance!, props.ref]
: null,
scopeId: currentScopeId,
// the next vnode so that it can be properly unmounted later.
if (
shouldTrack > 0 &&
- currentBlock !== null &&
+ currentBlock &&
// the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
patchFlag !== PatchFlags.HYDRATE_EVENTS &&
parentSuspense: any,
unmountChildren: any
) {
- if ((key === 'innerHTML' || key === 'textContent') && prevChildren != null) {
+ if ((key === 'innerHTML' || key === 'textContent') && prevChildren) {
unmountChildren(prevChildren, parentComponent, parentSuspense)
el[key] = value == null ? '' : value
return
export const nodeOps: Omit<RendererOptions<Node, Element>, 'patchProp'> = {
insert: (child, parent, anchor) => {
- if (anchor != null) {
+ if (anchor) {
parent.insertBefore(child, anchor)
} else {
parent.appendChild(child)
remove: child => {
const parent = child.parentNode
- if (parent != null) {
+ if (parent) {
parent.removeChild(child)
}
},
function insert(child: TestNode, parent: TestElement, ref?: TestNode | null) {
let refIndex
- if (ref != null) {
+ if (ref) {
refIndex = parent.children.indexOf(ref)
if (refIndex === -1) {
console.error('ref: ', ref)
function remove(child: TestNode, logOp: boolean = true) {
const parent = child.parentNode
- if (parent != null) {
+ if (parent) {
if (logOp) {
logNodeOp({
type: NodeOpTypes.REMOVE,
let { props, children, shapeFlag, scopeId, dirs } = vnode
let openTag = `<${tag}`
- if (dirs !== null) {
+ if (dirs) {
props = applySSRDirectives(vnode, props, dirs)
}
- if (props !== null) {
+ if (props) {
openTag += ssrRenderAttrs(props, tag)
}
- if (scopeId !== null) {
+ if (scopeId) {
openTag += ` ${scopeId}`
const treeOwnerId = parentComponent && parentComponent.type.__scopeId
// vnode's own scopeId and the current rendering component's scopeId is
// different - this is a slot content node.
- if (treeOwnerId != null && treeOwnerId !== scopeId) {
+ if (treeOwnerId && treeOwnerId !== scopeId) {
openTag += ` ${treeOwnerId}-s`
}
}
push(openTag + `>`)
if (!isVoidTag(tag)) {
let hasChildrenOverride = false
- if (props !== null) {
+ if (props) {
if (props.innerHTML) {
hasChildrenOverride = true
push(props.innerHTML)
projects / thirdparty / vuejs / core.git / commitdiff
