testaro 30.0.8 → 32.0.1

package/run.js

@@ -1,3 +1,25 @@
+/*
+  © 2021–2023 CVS Health and/or one of its affiliates. All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
 /*
   run.js
   Testaro main utility module.
@@ -9,11 +31,9 @@
 require('dotenv').config();
 // Requirements for acts.
 const {actSpecs} = require('./actSpecs');
-// Navigation.
-const {browserClose, getNonce, goTo, launch} = require('./procs/nav');
 // Module to standardize report formats.
 const {standardize} = require('./procs/standardize');
-// Module to send a notice to the server.
+// Module to send a notice to an observer.
 const {tellServer} = require('./procs/tellServer');
 
 // ########## CONSTANTS
@@ -34,7 +54,7 @@ const moves = {
   text: 'input'
 };
 // Names and descriptions of tools.
-const tests = {
+const tools = {
   alfa: 'alfa',
   aslint: 'ASLint',
   axe: 'Axe',
@@ -45,12 +65,34 @@ const tests = {
   testaro: 'Testaro',
   wave: 'WAVE',
 };
+// Strings in log messages indicating errors.
+const errorWords = [
+  'but not used',
+  'content security policy',
+  'deprecated',
+  'error',
+  'exception',
+  'expected',
+  'failed',
+  'invalid',
+  'missing',
+  'non-standard',
+  'not supported',
+  'refused',
+  'requires',
+  'sorry',
+  'suspicious',
+  'unrecognized',
+  'violates',
+  'warning'
+];
 
 // ########## VARIABLES
 
 // Facts about the current session.
 let actCount = 0;
 // Facts about the current browser.
+let browser;
 let browserContext;
 let currentPage;
 let requestedURL = '';
@@ -108,7 +150,7 @@ const hasSubtype = (variable, subtype) => {
       return isFocusable(variable);
     }
     else if (subtype === 'isTest') {
-      return tests[variable];
+      return tools[variable];
     }
     else if (subtype === 'isWaitable') {
       return ['url', 'title', 'body'].includes(variable);
@@ -145,13 +187,13 @@ const isValidAct = act => {
     // If the type is test:
     if (type === 'test') {
       // Identify the test.
-      const testName = act.which;
+      const toolName = act.which;
       // If one was specified and is known:
-      if (testName && tests[testName]) {
+      if (toolName && tools[toolName]) {
         // If it has special properties:
-        if (actSpecs.tests[testName]) {
+        if (actSpecs.tools[toolName]) {
           // Expand the validator by adding them.
-          Object.assign(validator, actSpecs.tests[testName][1]);
+          Object.assign(validator, actSpecs.tools[toolName][1]);
         }
       }
       // Otherwise, i.e. if no or an unknown test was specified:
@@ -233,7 +275,7 @@ const isValidReport = report => {
       return 'Bad report sources';
     }
     if (typeof sources.script !== 'string') {
-      return 'Bad sources script';
+      return 'Bad source script';
     }
     if (
       ! creationTime
@@ -254,6 +296,224 @@ const isValidReport = report => {
 
 // ########## OTHER FUNCTIONS
 
+// Returns a string with any final slash removed.
+const deSlash = string => string.endsWith('/') ? string.slice(0, -1) : string;
+// Gets the script nonce from a response.
+const getNonce = async response => {
+  let nonce = '';
+  // If the response includes a content security policy:
+  const headers = await response.allHeaders();
+  const cspWithQuotes = headers && headers['content-security-policy'];
+  if (cspWithQuotes) {
+    // If it requires scripts to have a nonce:
+    const csp = cspWithQuotes.replace(/'/g, '');
+    const directives = csp.split(/ *; */).map(directive => directive.split(/ +/));
+    const scriptDirective = directives.find(dir => dir[0] === 'script-src');
+    if (scriptDirective) {
+      const nonceSpec = scriptDirective.find(valPart => valPart.startsWith('nonce-'));
+      if (nonceSpec) {
+        // Return the nonce.
+        nonce = nonceSpec.replace(/^nonce-/, '');
+      }
+    }
+  }
+  // Return the nonce, if any.
+  return nonce;
+};
+// Visits a URL and returns the response of the server.
+const goTo = async (report, page, url, timeout, waitUntil) => {
+  // If the URL is a file path:
+  if (url.startsWith('file://')) {
+    // Make it absolute.
+    url = url.replace('file://', `file://${__dirname}/`);
+  }
+  // Visit the URL.
+  const startTime = Date.now();
+  try {
+    const response = await page.goto(url, {
+      timeout,
+      waitUntil
+    });
+    report.jobData.visitLatency += Math.round((Date.now() - startTime) / 1000);
+    const httpStatus = response.status();
+    // If the response status was normal:
+    if ([200, 304].includes(httpStatus) || url.startsWith('file:')) {
+      // If the browser was redirected in violation of a strictness requirement:
+      const actualURL = page.url();
+      if (report.strict && deSlash(actualURL) !== deSlash(url)) {
+        // Return an error.
+        console.log(`ERROR: Visit to ${url} redirected to ${actualURL}`);
+        return {
+          exception: 'badRedirection'
+        };
+      }
+      // Otherwise, i.e. if no prohibited redirection occurred:
+      else {
+        // Press the Escape key to dismiss any modal dialog.
+        await page.keyboard.press('Escape');
+        // Return the result of the navigation.
+        return {
+          success: true,
+          response
+        };
+      }
+    }
+    // Otherwise, i.e. if the response status was abnormal:
+    else {
+      // Return an error.
+      console.log(`ERROR: Visit to ${url} got status ${httpStatus}`);
+      report.jobData.visitRejectionCount++;
+      return {
+        success: false,
+        error: 'badStatus'
+      };
+    }
+  }
+  catch(error) {
+    console.log(`ERROR visiting ${url} (${error.message.slice(0, 200)})`);
+    return {
+      success: false,
+      error: 'noVisit'
+    };
+  }
+};
+// Closes the current browser.
+const browserClose = async () => {
+  if (browser) {
+    let contexts = browser.contexts();
+    for (const context of contexts) {
+      await context.close();
+      contexts = browser.contexts();
+    }
+    await browser.close();
+    browser = null;
+  }
+};
+// Launches a browser, navigates to a URL, and returns browser data.
+const launch = async (report, typeName, url, debug, waits, isLowMotion = false) => {
+  // If the specified browser type exists:
+  const browserType = require('playwright')[typeName];
+  if (browserType) {
+    // Close the current browser, if any.
+    await browserClose();
+    // Launch a browser of the specified type.
+    const browserOptions = {
+      logger: {
+        isEnabled: () => false,
+        log: (name, severity, message) => console.log(message.slice(0, 100))
+      }
+    };
+    if (debug) {
+      browserOptions.headless = false;
+    }
+    if (waits) {
+      browserOptions.slowMo = waits;
+    }
+    browser = await browserType.launch(browserOptions)
+    // If the launch failed:
+    .catch(async error => {
+      console.log(`ERROR launching browser (${error.message.slice(0, 200)})`);
+      // Return this.
+      return {
+        success: false,
+        error: 'Browser launch failed'
+      };
+    });
+    // Open a context (i.e. browser tab), with reduced motion if specified.
+    const options = {reduceMotion: isLowMotion ? 'reduce' : 'no-preference'};
+    const browserContext = await browser.newContext(options);
+    // When a page (i.e. browser tab) is added to the browser context (i.e. browser window):
+    browserContext.on('page', async page => {
+      // If it emits a message:
+      page.on('console', msg => {
+        const msgText = msg.text();
+        let indentedMsg = '';
+        // If debugging is on:
+        if (debug) {
+          // Log a summary of the message on the console.
+          const parts = [msgText.slice(0, 75)];
+          if (msgText.length > 75) {
+            parts.push(msgText.slice(75, 150));
+            if (msgText.length > 150) {
+              const tail = msgText.slice(150).slice(-150);
+              if (msgText.length > 300) {
+                parts.push('...');
+              }
+              parts.push(tail.slice(0, 75));
+              if (tail.length > 75) {
+                parts.push(tail.slice(75));
+              }
+            }
+          }
+          indentedMsg = parts.map(part => `    | ${part}`).join('\n');
+          console.log(`\n${indentedMsg}`);
+        }
+        // Add statistics on the message to the report.
+        const msgTextLC = msgText.toLowerCase();
+        const msgLength = msgText.length;
+        report.jobData.logCount++;
+        report.jobData.logSize += msgLength;
+        if (errorWords.some(word => msgTextLC.includes(word))) {
+          report.jobData.errorLogCount++;
+          report.jobData.errorLogSize += msgLength;
+        }
+        const msgLC = msgText.toLowerCase();
+        if (
+          msgText.includes('403') && (msgLC.includes('status')
+          || msgLC.includes('prohibited'))
+        ) {
+          report.jobData.prohibitedCount++;
+        }
+      });
+    });
+    // Open the first page of the context.
+    const page = await browserContext.newPage();
+    try {
+      // Wait until it is stable.
+      await page.waitForLoadState('domcontentloaded', {timeout: 5000});
+      // Navigate to the specified URL.
+      const navResult = await goTo(report, page, url, 15000, 'domcontentloaded');
+      // If the navigation succeeded:
+      if (navResult.success) {
+        // Update the name of the current browser type and store it in the page.
+        page.browserTypeName = typeName;
+        // Return the response of the target server, the browser context, and the page.
+        return {
+          success: true,
+          response: navResult.response,
+          browserContext,
+          page
+        };
+      }
+      // Otherwise, if the navigation failed:
+      else if (navResult.error) {
+        // Return this.
+        return {
+          success: false,
+          error: 'Navigation failed'
+        };
+      }
+    }
+    // If it fails to become stable after load:
+    catch(error) {
+      // Return this.
+      console.log(`ERROR: Blank page load in new tab timed out (${error.message})`);
+      return {
+        success: false,
+        error: 'Blank page load in new tab timed out'
+      };
+    }
+  }
+  // Otherwise, i.e. if it does not exist:
+  else {
+    // Return this.
+    console.log(`ERROR: Browser of type ${typeName} could not be launched`);
+    return {
+      success: false,
+      error: `${typeName} browser launch failed`
+    };
+  }
+};
 // Returns a string representing the date and time.
 const nowString = () => (new Date()).toISOString().slice(0, 19);
 // Returns the first line of an error message.
@@ -421,23 +681,51 @@ const wait = ms => {
     }, ms);
   });
 };
+// Reports a job being aborted and returns an abortive act index.
+const abortActs = async (report, actIndex) => {
+  // Add data on the aborted act to the report.
+  report.jobData.abortTime = nowString();
+  report.jobData.abortedAct = actIndex;
+  report.jobData.aborted = true;
+  // Report the job being aborted.
+  console.log('ERROR: Job aborted');
+  // Return an abortive act index.
+  return -2;
+};
 // Adds an error result to an act.
-const addError = (alsoLog, act, error, message) => {
+const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
+  // If the error is to be logged:
   if (alsoLog) {
-    console.log(`${message} (${error})`);
-  }
-  if (! act.result) {
-    act.result = {};
+    // Log it.
+    console.log(message);
   }
-  act.result.success = false;
-  act.result.error = error;
-  act.result.message = message;
+  // Add error data to the result.
+  const act = report.acts[actIndex];
+  act.result ??= {};
+  act.result.success ??= false;
+  act.result.error ??= message;
   if (act.type === 'test') {
-    act.result.prevented = true;
+    act.data.success = false;
+    act.data.prevented = true;
+    act.data.error = message;
+    // Add prevention data to the job data.
+    report.jobData.preventions[act.which] = message;
+  }
+  // If the job is to be aborted:
+  if (alsoAbort) {
+    console.log(`report:\n${JSON.stringify(report, null, 2)}`);
+    // Return an abortive act index.
+    return await abortActs(report, actIndex);
+  }
+  // Otherwise, i.e. if the job is not to be aborted:
+  else {
+    // Return the current act index.
+    return actIndex;
   }
 };
 // Recursively performs the acts in a report.
 const doActs = async (report, actIndex, page) => {
+  // FUNCTION DEFINITION START
   // Quits and reports the job being aborted.
   const abortActs = async () => {
     // Add data on the aborted act to the report.
@@ -449,6 +737,7 @@ const doActs = async (report, actIndex, page) => {
     // Report this.
     console.log('ERROR: Job aborted');
   };
+  // FUNCTION DEFINITION END
   const {acts} = report;
   // If any more acts are to be performed:
   if (actIndex > -1 && actIndex < acts.length) {
@@ -533,10 +822,10 @@ const doActs = async (report, actIndex, page) => {
         }
         // Otherwise, i.e. if the launch or navigation failed:
         else {
-          // Add an error result to the act.
-          addError(true, act, 'badLaunch', `ERROR: Launch failed (${launchResult.error})`);
-          // Abort the job.
-          await abortActs();
+          // Add an error result to the act and abort the job.
+          actIndex = await addError(
+            true, true, report, actIndex, `ERROR: Launch failed (${launchResult.error})`
+          );
         }
       }
       // Otherwise, if a current page exists:
@@ -563,15 +852,15 @@ const doActs = async (report, actIndex, page) => {
             act.result.url = page.url();
             // If a prohibited redirection occurred:
             if (response.exception === 'badRedirection') {
-              // Report this and quit.
-              addError(true, act, 'badRedirection', 'ERROR: Navigation illicitly redirected');
-              await abortActs();
+              // Report this and abort the job.
+              actIndex = await addError(
+                true, true, report, actIndex, 'ERROR: Navigation illicitly redirected'
+              );
             }
             // Otherwise, i.e. if the visit failed:
             else {
-              // Report this and quit.
-              addError(true, act, 'failure', 'ERROR: Visit failed');
-              await abortActs();
+              // Report this and abort the job.
+              actIndex = await addError(true, true, report, actIndex, 'ERROR: Visit failed');
             }
           }
         }
@@ -652,10 +941,11 @@ const doActs = async (report, actIndex, page) => {
           )
           // If the wait times out:
           .catch(async error => {
-            // Quit.
+            // Report this and abort the job.
             console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
-            addError(true, act, 'timeout', `ERROR waiting for page to be ${act.which}`);
-            await abortActs();
+            actIndex = await addError(
+              true, true, report, actIndex, `ERROR waiting for page to be ${act.which}`
+            );
           });
           // If the wait succeeded:
           if (actIndex > -2) {
@@ -686,21 +976,35 @@ const doActs = async (report, actIndex, page) => {
           // If the act is a revelation:
           if (act.type === 'reveal') {
             // Make all elements in the page visible.
-            await require('./procs/allVis').allVis(page);
-            act.result = {
-              success: true
-            };
+            await page.$$eval('body *', elements => {
+              elements.forEach(element => {
+                const styleDec = window.getComputedStyle(element);
+                if (styleDec.display === 'none') {
+                  element.style.display = 'initial';
+                }
+                if (['hidden', 'collapse'].includes(styleDec.visibility)) {
+                  element.style.visibility = 'inherit';
+                }
+              });
+              act.result = {
+                success: true
+              };
+            })
+            .catch(error => {
+              console.log(`ERROR making all elements visible (${error.message})`);
+              act.result = {
+                success: false
+              };
+            });
           }
           // Otherwise, if the act performs tests of a tool:
           else if (act.type === 'test') {
-            // Add a description of the test to the act.
-            act.what = tests[act.which];
+            // Add a description of the tool to the act.
+            act.what = tools[act.which];
             // Initialize the options argument.
             const options = {
               report,
-              act,
-              granular: report.observe,
-              scriptNonce: report.jobData.lastScriptNonce || ''
+              act
             };
             // Add any specified arguments to it.
             Object.keys(act).forEach(key => {
@@ -708,33 +1012,34 @@ const doActs = async (report, actIndex, page) => {
                 options[key] = act[key];
               }
             });
-            // Initialize the test report.
+            // Get the start time of the act.
             const startTime = Date.now();
-            let toolReport = {
-              result: {
-                success: false
-              }
-            };
             // Perform the specified tests of the tool and get a report.
             try {
-              toolReport = await require(`./tests/${act.which}`).reporter(page, options);
-              toolReport.result.success = true;
+              const actReport = await require(`./tests/${act.which}`).reporter(page, options);
+              // Import its test results and process data into the act.
+              act.result = actReport && actReport.result || {};
+              act.data = actReport && actReport.data || {};
+              // If the page prevented the tool from operating:
+              if (act.data.prevented) {
+                // Add prevention data to the job data.
+                report.jobData.preventions[act.which] = act.data.error;
+              }
             }
             // If the testing failed:
             catch(error) {
-              // Report this but do not abort the job.
-              console.log(`ERROR: Test act ${act.which} failed (${error.message.slice(0, 400)})`);
+              // Report this.
+              const message = error.message.slice(0, 400);
+              console.log(`ERROR: Test act ${act.which} failed (${message})`);
+              act.data.error = act.data.error ? `${act.data.error}; ${message}` : message;
             }
-            // Add the elapsed time to the report.
+            // Add the elapsed time of the tool to the report.
             const time = Math.round((Date.now() - startTime) / 1000);
             const {toolTimes} = report.jobData;
             if (! toolTimes[act.which]) {
               toolTimes[act.which] = 0;
             }
             toolTimes[act.which] += time;
-            // Add the result object (possibly an array) to the act.
-            const resultCount = Object.keys(toolReport.result).length;
-            act.result = resultCount ? toolReport.result : {success: false};
             // If a standard-format result is to be included in the report:
             const standard = report.standard || 'only';
             if (['also', 'only'].includes(standard)) {
@@ -747,14 +1052,10 @@ const doActs = async (report, actIndex, page) => {
               standardize(act);
               // If the original-format result is not to be included in the report:
               if (standard === 'only') {
-                // Remove it, except any important property.
-                if (act.result.important) {
-                  act.data = act.result.important;
-                  console.log(`>>>>>> Important ${act.which} data included in report`);
-                }
+                // Remove it.
                 delete act.result;
               }
-              // If the test has expectations:
+              // If the act has expectations:
               const expectations = act.expect;
               if (expectations) {
                 // Initialize whether they were fulfilled.
@@ -871,10 +1172,8 @@ const doActs = async (report, actIndex, page) => {
                 }
                 // If the move fails:
                 catch(error) {
-                  // Add the error result to the act.
-                  addError(true, act, 'moveFailure', `ERROR: ${move} failed`);
-                  // Abort.
-                  await abortActs();
+                  // Add the error result to the act and abort the job.
+                  actIndex = await addError(true, true, report, actIndex, `ERROR: ${move} failed`);
                 }
                 if (act.result.success) {
                   try {
@@ -1210,37 +1509,27 @@ const doActs = async (report, actIndex, page) => {
           }
           // Otherwise, i.e. if the act type is unknown:
           else {
-            // Add the error result to the act.
-            addError(true, act, 'badType', 'ERROR: Invalid act type');
-            // Abort.
-            await abortActs();
+            // Add the error result to the act and abort the job.
+            actIndex = await addError(true, true, report, actIndex, 'ERROR: Invalid act type');
           }
         }
         // Otherwise, a page URL is required but does not exist, so:
         else {
-          // Add an error result to the act.
-          addError(true, act, 'noURL', 'ERROR: Page has no URL');
-          // Abort.
-          await abortActs();
+          // Add an error result to the act and abort the job.
+          actIndex = await addError(true, true, report, actIndex, 'ERROR: Page has no URL');
         }
       }
       // Otherwise, i.e. if no page exists:
       else {
-        // Add an error result to the act.
-        addError(true, act, 'noPage', 'ERROR: No page identified');
-        // Abort.
-        await abortActs();
+        // Add an error result to the act and abort the job.
+        actIndex = await addError(true, true, report, actIndex, 'ERROR: No page identified');
       }
       act.endTime = Date.now();
     }
     // Otherwise, i.e. if the act is invalid:
     else {
-      // Quit and add error data to the report.
-      const errorMsg = `ERROR: Invalid act of type ${act.type}`;
-      console.log(errorMsg);
-      addError(true, act, 'badAct', errorMsg);
-      // Abort.
-      await abortActs();
+      // Add error data to the act and abort the job.
+      addError(true, true, report, actIndex, `ERROR: Invalid act of type ${act.type}`);
     }
     // Perform any remaining acts if not aborted.
     await doActs(report, actIndex + 1, page);
@@ -1280,6 +1569,7 @@ exports.doJob = async report => {
     report.jobData.presses = 0;
     report.jobData.amountRead = 0;
     report.jobData.toolTimes = {};
+    report.jobData.preventions = {};
     process.on('message', message => {
       if (message === 'interrupt') {
         console.log('ERROR: Terminal interrupted the job');

package/testaro/allCaps.js

@@ -1,3 +1,25 @@
+/*
+  © 2023 CVS Health and/or one of its affiliates. All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
 /*
   allCaps
   Related to Tenon rule 153.

package/testaro/allHidden.js

@@ -1,3 +1,25 @@
+/*
+  © 2023 CVS Health and/or one of its affiliates. All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
 /*
   allHidden
   This test reports a page that is entirely or mainly hidden.