/** * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /** * @fileoverview Checks to see if images are displayed only outside of the viewport. * Images requested after TTI are not flagged as violations. */ 'use strict'; const ByteEfficiencyAudit = require('./byte-efficiency-audit.js'); const Sentry = require('../../lib/sentry.js'); const URL = require('../../lib/url-shim.js'); const i18n = require('../../lib/i18n/i18n.js'); const Interactive = require('../../computed/metrics/interactive.js'); const TraceOfTab = require('../../computed/trace-of-tab.js'); const UIStrings = { /** Imperative title of a Lighthouse audit that tells the user to defer loading offscreen images. Offscreen images are images located outside of the visible browser viewport. As they are unseen by the user and slow down page load, they should be loaded later, closer to when the user is going to see them. This is displayed in a list of audit titles that Lighthouse generates. */ title: 'Defer offscreen images', /** Description of a Lighthouse audit that tells the user *why* they should defer loading offscreen images. Offscreen images are images located outside of the visible browser viewport. As they are unseen by the user and slow down page load, they should be loaded later, closer to when the user is going to see them. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */ description: 'Consider lazy-loading offscreen and hidden images after all critical resources have ' + 'finished loading to lower time to interactive. ' + '[Learn more](https://web.dev/offscreen-images/).', }; const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings); // See https://github.com/GoogleChrome/lighthouse/issues/10471 for discussion about the thresholds here. const ALLOWABLE_OFFSCREEN_IN_PX = 100; const ALLOWABLE_OFFSCREEN_BOTTOM_IN_VIEWPORTS = 3; const IGNORE_THRESHOLD_IN_BYTES = 2048; const IGNORE_THRESHOLD_IN_PERCENT = 75; const IGNORE_THRESHOLD_IN_MS = 50; /** @typedef {{url: string, requestStartTime: number, totalBytes: number, wastedBytes: number, wastedPercent: number}} WasteResult */ class OffscreenImages extends ByteEfficiencyAudit { /** * @return {LH.Audit.Meta} */ static get meta() { return { id: 'offscreen-images', title: str_(UIStrings.title), description: str_(UIStrings.description), scoreDisplayMode: ByteEfficiencyAudit.SCORING_MODES.NUMERIC, requiredArtifacts: ['ImageElements', 'ViewportDimensions', 'devtoolsLogs', 'traces'], }; } /** * @param {{top: number, bottom: number, left: number, right: number}} imageRect * @param {{innerWidth: number, innerHeight: number}} viewportDimensions * @return {number} */ static computeVisiblePixels(imageRect, viewportDimensions) { const innerWidth = viewportDimensions.innerWidth; const innerHeight = viewportDimensions.innerHeight; const allowableOffscreenBottomInPx = ALLOWABLE_OFFSCREEN_BOTTOM_IN_VIEWPORTS * viewportDimensions.innerHeight; const top = Math.max(imageRect.top, -1 * ALLOWABLE_OFFSCREEN_IN_PX); const right = Math.min(imageRect.right, innerWidth + ALLOWABLE_OFFSCREEN_IN_PX); const bottom = Math.min(imageRect.bottom, innerHeight + allowableOffscreenBottomInPx); const left = Math.max(imageRect.left, -1 * ALLOWABLE_OFFSCREEN_IN_PX); return Math.max(right - left, 0) * Math.max(bottom - top, 0); } /** * @param {LH.Artifacts.ImageElement} image * @param {{innerWidth: number, innerHeight: number}} viewportDimensions * @param {Array} networkRecords * @return {null|Error|WasteResult} */ static computeWaste(image, viewportDimensions, networkRecords) { const networkRecord = networkRecords.find(record => record.url === image.src); // If we don't know how big it was, we can't really report savings, treat it as passed. if (!image.resourceSize || !networkRecord) return null; // If the image had its loading behavior explicitly controlled already, treat it as passed. if (image.loading === 'lazy' || image.loading === 'eager') return null; const url = URL.elideDataURI(image.src); const totalPixels = image.displayedWidth * image.displayedHeight; const visiblePixels = this.computeVisiblePixels(image.clientRect, viewportDimensions); // Treat images with 0 area as if they're offscreen. See https://github.com/GoogleChrome/lighthouse/issues/1914 const wastedRatio = totalPixels === 0 ? 1 : 1 - visiblePixels / totalPixels; const totalBytes = image.resourceSize; const wastedBytes = Math.round(totalBytes * wastedRatio); if (!Number.isFinite(wastedRatio)) { return new Error(`Invalid image sizing information ${url}`); } return { url, requestStartTime: networkRecord.startTime, totalBytes, wastedBytes, wastedPercent: 100 * wastedRatio, }; } /** * Filters out image requests that were requested after the last long task based on lantern timings. * * @param {WasteResult[]} images * @param {LH.Artifacts.LanternMetric} lanternMetricData */ static filterLanternResults(images, lanternMetricData) { const nodeTimings = lanternMetricData.pessimisticEstimate.nodeTimings; // Find the last long task start time let lastLongTaskStartTime = 0; // Find the start time of all requests /** @type {Map} */ const startTimesByURL = new Map(); for (const [node, timing] of nodeTimings) { if (node.type === 'cpu' && timing.duration >= 50) { lastLongTaskStartTime = Math.max(lastLongTaskStartTime, timing.startTime); } else if (node.type === 'network') { const networkNode = /** @type {LH.Gatherer.Simulation.GraphNetworkNode} */ (node); startTimesByURL.set(networkNode.record.url, timing.startTime); } } return images.filter(image => { // Filter out images that had little waste if (image.wastedBytes < IGNORE_THRESHOLD_IN_BYTES) return false; if (image.wastedPercent < IGNORE_THRESHOLD_IN_PERCENT) return false; // Filter out images that started after the last long task const imageRequestStartTime = startTimesByURL.get(image.url) || 0; return imageRequestStartTime < lastLongTaskStartTime - IGNORE_THRESHOLD_IN_MS; }); } /** * Filters out image requests that were requested after TTI. * * @param {WasteResult[]} images * @param {number} interactiveTimestamp */ static filterObservedResults(images, interactiveTimestamp) { return images.filter(image => { if (image.wastedBytes < IGNORE_THRESHOLD_IN_BYTES) return false; if (image.wastedPercent < IGNORE_THRESHOLD_IN_PERCENT) return false; return image.requestStartTime < interactiveTimestamp / 1e6 - IGNORE_THRESHOLD_IN_MS / 1000; }); } /** * The default byte efficiency audit will report max(TTI, load), since lazy-loading offscreen * images won't reduce the overall time and the wasted bytes are really only "wasted" for TTI, * override the function to just look at TTI savings. * * @param {Array} results * @param {LH.Gatherer.Simulation.GraphNode} graph * @param {LH.Gatherer.Simulation.Simulator} simulator * @return {number} */ static computeWasteWithTTIGraph(results, graph, simulator) { return super.computeWasteWithTTIGraph(results, graph, simulator, {includeLoad: false}); } /** * @param {LH.Artifacts} artifacts * @param {Array} networkRecords * @param {LH.Audit.Context} context * @return {Promise} */ static async audit_(artifacts, networkRecords, context) { const images = artifacts.ImageElements; const viewportDimensions = artifacts.ViewportDimensions; const trace = artifacts.traces[ByteEfficiencyAudit.DEFAULT_PASS]; const devtoolsLog = artifacts.devtoolsLogs[ByteEfficiencyAudit.DEFAULT_PASS]; /** @type {string[]} */ const warnings = []; const resultsMap = images.reduce((results, image) => { const processed = OffscreenImages.computeWaste(image, viewportDimensions, networkRecords); if (processed === null) { return results; } if (processed instanceof Error) { warnings.push(processed.message); Sentry.captureException(processed, {tags: {audit: this.meta.id}, level: 'warning'}); return results; } // If an image was used more than once, warn only about its least wasteful usage const existing = results.get(processed.url); if (!existing || existing.wastedBytes > processed.wastedBytes) { results.set(processed.url, processed); } return results; }, /** @type {Map} */ (new Map())); const settings = context.settings; let items; const unfilteredResults = Array.from(resultsMap.values()); // get the interactive time or fallback to getting the end of trace time try { const interactive = await Interactive.request({trace, devtoolsLog, settings}, context); // use interactive to generate items const lanternInteractive = /** @type {LH.Artifacts.LanternMetric} */ (interactive); // Filter out images that were loaded after all CPU activity items = context.settings.throttlingMethod === 'simulate' ? OffscreenImages.filterLanternResults(unfilteredResults, lanternInteractive) : // @ts-expect-error - .timestamp will exist if throttlingMethod isn't lantern OffscreenImages.filterObservedResults(unfilteredResults, interactive.timestamp); } catch (err) { // if the error is during a Lantern run, end of trace may also be inaccurate, so rethrow if (context.settings.throttlingMethod === 'simulate') { throw err; } // use end of trace as a substitute for finding interactive time items = OffscreenImages.filterObservedResults(unfilteredResults, await TraceOfTab.request(trace, context).then(tot => tot.timestamps.traceEnd)); } /** @type {LH.Audit.Details.Opportunity['headings']} */ const headings = [ {key: 'url', valueType: 'thumbnail', label: ''}, {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)}, {key: 'totalBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnResourceSize)}, {key: 'wastedBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnWastedBytes)}, ]; return { warnings, items, headings, }; } } module.exports = OffscreenImages; module.exports.UIStrings = UIStrings;
lady scott
lady scott
youth choir

I can show you better than I can tell you.


Union Missionary Baptist Church exists to share the love of Jesus Christ through evangelism, encourage one another through fellowship, help one another become more like Jesus through discipleship, serve others through ministry, and express our love to God through worship.
Just take a look at how mindful the Lord is of you! As a child of God you are too blessed to be stressed out over your present situations and circumstances. There are so many blessings that you have not even begun to tap into yet that eyes have not seen nor ears heard about. Every morning that you rise, realize that His mercies are new each morning, for great is His faithfulness. As you go throughout your day our prayer is that you’ll recognize the goodness of our God like never before and that you’ll experience the hand of the Lord working on your behalf in the midst of anything that may try to come against you.


Worship Service

Sunday mornings @ 11am​

The Holy and Almighty God serves His people through Word and Sacrament and we respond withprayer, praise and thanksgiving, giving our adoration and worship to the Father, Son and Holy Spirit  The Bible is clear that our lives are worship to God (Rom 12:1-2).

This worship service brings together a full choir, stirring music and powerful preaching. UMBC’s sanctuary is the perfect setting for a moving worship experience, complemented with the warmth of an open and welcoming congregation.  Childcare is available and a free continental breakfast is offered

Midweek Bible Study

Wednesday nights  @ 6:30pm

Take my yoke upon you, and learn of me; for I am meek and lowly in heart: and ye shall find rest unto your souls.—Matthew 11:29

The association of Bible study and prayer is an important one. Christians do not merely study the Bible as an academic disciple, but with the desire to know God better. Therefore we frequently pray that God will give us understanding. To us, the Bible is not just a sacred book, but is the very Word of God, that is, a message from God which has direct relevance to our daily lives.

Sunday School

Sunday's @ 8:30 and 9:30 am

The  purpose of Sunday School is to change lives for Jesus Christ by  evangelizing the lost and discipling to those who respond to the Gospel  through our classes. We offer classes for all ages. 

  • Reaching the needs of people for Jesus Christ and Church Membership.

  • Ministering to class members through Christian fellowship.

  • Teaching class members the Word of God to equip them as disciples of Christ.

  • Helping class members find a place of service to help them grow in their faith



UMBC is about life change. We are a culturally relevant growing church that is reaching people from all walks of life who are being transformed by Jesus Christ. Our mission, based on the Great Commission, is to help people Know Jesus, Grow together in Him, & Go serve the world. This forms the basis for everything we do.
For volunteer opportunities contact us.

Small Group Ministries

A Small Group

  • is an intentional gathering. This group of people agree to share life together. They plan where and when to meet and arrange their schedules to be there. They have a purpose for getting together.

  • meets regularly. A small group has a regular meeting time and schedule. The groups know when to expect their next gathering.

  • for the purpose of joining God’s mission. People in small groups desire to be formed as Christ’s disciples and as such they will naturally join in God’s mission.


Youth of the Word - YOW

Our mission is to foster an environment of spiritual growth through biblical learning and hands on activities. We teach respect, knowledge, and responsibility by following the word of God and His principles stated in Proverbs 22:6, “Train up a child in the way he should go, And when he is old, he will not depart from it”.

Brothers of the Word - BOW
Women of the Word - WOW

Brothers, Women and Youth of the Word
Every 2nd Thursday @ 6:30pm

Our purpose is to grow stronger in the Word of God by living it daily, coming to unity of the faith, oneness with God, and each other so that we can reach our full potential. 
Our Vision is to be healed, delivered, and set free from whatever it is that binds/hinders/limits our gifts and calling (Ministry Mission) from coming forward to fruition.
Mission Statement
WOW, BOW, and YOW are here to build people of purpose, power, and praise!

Pastor Scott


Corey D. Scott


Trust God
Trust the Process



219 Gulpha St, Hot Springs, AR 71901, USA

©2020 by Union Missionary Baptist Church