Agent skill

Accessibility Robust

by hashgraph-online in hashgraph-online/awesome-codex-plugins

A skill your agent uses when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI.

Apache-2.0Auto-check passedFrontend & Design

Install Accessibility Robust

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill accessibility-robust -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins accessibility-robust --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/HDeibler/universal-design-principles/plugins/process-and-robustness-principles/skills/accessibility-robust .claude/skills/accessibility-robust && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
accessibility-robust
GitHub stars
1.3k
Token cost
~3.4k tokens
SKILL.md length
1,330 words
Files
2 (incl. references)
Skills in repo
714
Repo updated
First seen
Licence
Apache-2.0

At a glance

A skill your agent uses when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI.

  • Works in 2 steps: Compatible → Status messages
  • The question is whether assistive technologies — screen readers
  • SKILL.md covers 1. Compatible, 2. Status messages, Worked examples and Anti-patterns, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Accessibility Robust is an agent skill from hashgraph-online/awesome-codex-plugins. Use this skill when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI. Trigger when picking between semantic HTML and a custom-built component, when reaching for ARIA, when designing live regions for dynamic content (toasts, validation, search results), or when reviewing a UI built largely from <div elements. Covers WCAG Principle 4 (Robust). Sub-aspect of accessibility; read that first if you haven't…

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/robust-deep-dive.md`).

It sits in Frontend & Design, covering Accessibility. The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is Apache-2.0.

When your agent uses it

  • The question is whether assistive technologies — screen readers
  • Refreshable braille displays — can reliably interpret your UI
  • Picking between semantic HTML and a custom-built component
  • Reaching for ARIA

Example prompts

  • “/accessibility-robust”

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Compatible
  2. Status messages

What it can do on your machine

Read from SKILL.md and the folder at commit 9e7b281. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are html).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Accessibility Robust loads about 3.4k tokens when it runs, and up to ~5k if it reads all its reference files. Until then it costs about 137 tokens; SKILL.md has 1,330 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~137
When it runs · the whole SKILL.md, loaded when a task matches
~3.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hashgraph-online/awesome-codex-plugins at commit 9e7b281, republished under its Apache-2.0 licence (© hashgraph-online). 1,330 words, ~3,372 tokens.

Download SKILL.mdSave it as .claude/skills/accessibility-robust/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
accessibility-robust
description
Use this skill when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI. Trigger when picking between semantic HTML and a custom-built component, when reaching for ARIA, when designing live regions for dynamic content (toasts, validation, search results), or when reviewing a UI built largely from `<div>` elements. Covers WCAG Principle 4 (Robust). Sub-aspect of `accessibility`; read that first if you haven't already.

Accessibility — Robust

WCAG Principle 4: content must be robust enough to be interpreted reliably by a wide variety of user agents, including assistive technologies.

The two sub-criteria, simplified:

  1. Compatible — markup is parsed correctly; name, role, and value are programmatically determinable for every UI component.
  2. Status messages — programmatically-conveyed status updates without focus shifts.

Robustness is the layer most often broken by frameworks that abstract away HTML semantics. A <div>-based UI may be visually identical to a semantic one and entirely opaque to assistive tech.

1. Compatible

Semantic HTML first

Use the right HTML element for the job. Browsers and assistive tech understand semantic elements without further annotation.

Use this……not this
<button><div> with click handler
<a href><span> with click handler
<input type="checkbox"><div> with custom toggle
<nav><div class="nav">
<main><div class="main">
<form><div> with submit button
<label for="id"><div> next to an input
<table> for tabular datanested divs styled as a grid

The reason isn't aesthetic; semantic elements come with built-in:

  • Keyboard handling (<button> activates on Enter/Space).
  • Focus management (<a href> is in tab order).
  • Accessibility tree role (<nav> is announced as "navigation landmark").
  • Default styling that can be overridden but indicates affordance.
  • Form submission, validation, and serialization.

A <div role="button" tabindex="0" onclick onKeyDown> is almost a button — and you've rebuilt 80% of what <button> provides for free, often imperfectly.

Name, Role, Value

Every interactive component must have:

  • Name — what is it? ("Save," "Email field," "Open menu")
  • Role — what kind of thing is it? ("button," "textbox," "menu")
  • Value — what's its current state? ("checked," "expanded," "disabled," current text)

Native HTML elements provide all three for free. For custom components, you provide them via ARIA.

html
<!-- Native: name from text, role from <button>, value from disabled state -->
<button disabled>Save</button>

<!-- Custom: must declare all three -->
<div role="button"
     tabindex="0"
     aria-disabled="true">
  Save
</div>
When to use ARIA

The first rule of ARIA: don't use ARIA. The second rule: don't use ARIA when a native element will do. The third rule: when you must use ARIA, use it correctly.

Use ARIA when:

  • Building a custom component for which no native element exists (combobox, tablist, treegrid, slider) — use the appropriate WAI-ARIA pattern.
  • Adding state to a component that has no native attribute (aria-expanded, aria-current, aria-pressed, aria-selected).
  • Providing an accessible name when no visible label exists (aria-label, aria-labelledby).
  • Associating descriptions or errors with controls (aria-describedby).
  • Marking dynamic content for announcement (aria-live).

Don't use ARIA to:

  • Reinvent native semantics (role="button" on <button>).
  • Override semantics that work (role="presentation" on a <table> of tabular data).
  • "Fix" inaccessible custom components without also adding keyboard support and state management.
ARIA roles, properties, states

A few of the most-used:

AttributePurposeExample
roleDeclare what kind of widgetrole="dialog"
aria-labelAccessible name when no visible label<button aria-label="Close">×</button>
aria-labelledbyAccessible name from another element<dialog aria-labelledby="title">
aria-describedbyDescription / error / hint<input aria-describedby="hint">
aria-expandedDisclosure state<button aria-expanded="false">
aria-currentCurrent item in a set<a aria-current="page">
aria-pressedToggle button state<button aria-pressed="true">
aria-checkedCustom checkbox/radio state<div role="checkbox" aria-checked="true">
aria-selectedSelected item in a listbox<div role="option" aria-selected="true">
aria-disabledDisabled (when disabled attr unavailable)<div aria-disabled="true">
aria-invalidError state<input aria-invalid="true">
aria-requiredRequired field<input aria-required="true">
aria-hiddenHide from accessibility tree<svg aria-hidden="true">
aria-liveAnnounce changes<div aria-live="polite">
role="alert"Important announcement<div role="alert">

The WAI-ARIA Authoring Practices Guide documents complete patterns for: combobox, dialog, disclosure, feed, grid, listbox, menu, menubar, radiogroup, slider, tablist, treeview, and more. Reach for these patterns rather than inventing.

Don't break native semantics

A common mistake: applying ARIA roles that conflict with the underlying element.

html
<!-- Wrong: <a href> is already a link; role="button" overrides -->
<a href="/save" role="button">Save</a>

<!-- Wrong: <ul> already has list semantics; role="navigation" doesn't help -->
<ul role="navigation">...</ul>

<!-- Wrong: <table> for tabular data with role="presentation" strips semantics -->
<table role="presentation">...</table>

If you must override semantics (rare), you almost always have the wrong base element.

Validate your HTML

Invalid HTML can cascade in unpredictable ways through accessibility tree construction. Validate occasionally with the W3C HTML Validator.

Common offenders:

  • Duplicate IDs (breaks aria-labelledby and aria-describedby).
  • Nested interactive elements (<button> inside <a>, <a> inside <button>).
  • <button> inside <button>.
  • Form controls not associated with <label>.

2. Status messages

Dynamic content updates that don't shift focus need to be announced to screen readers via live regions.

Live regions
html
<!-- Polite: announce when convenient (after current speech) -->
<div aria-live="polite" id="search-results-status"></div>

<!-- Assertive: interrupt; for critical messages only -->
<div aria-live="assertive" id="error-status"></div>

When you populate the live region, the screen reader reads the new content. The region must:

  • Be present in the DOM before content is added (live regions don't announce content present at page load).
  • Have only the new message inside it, replacing previous content.
  • Be visible to assistive tech (don't display: none; use sr-only if you don't want it visible).
role="status" and role="alert"

Convenience roles with built-in aria-live settings:

  • role="status" ≈ aria-live="polite". For non-critical updates ("Saved," "Loaded 24 results").
  • role="alert" ≈ aria-live="assertive" plus aria-atomic="true". For urgent updates ("Connection lost," "Form has 3 errors").
html
<!-- Toast notification (status) -->
<div role="status">Changes saved</div>

<!-- Form error summary (alert) -->
<div role="alert">
  Please fix the following: Email is invalid; Password is too short.
</div>

Use role="alert" sparingly — it interrupts whatever the screen reader is doing. Reserve for genuine emergencies.

Common live-region patterns
  • Toast notifications — role="status" for success, info, warning; role="alert" for error.
  • Search results count — <div role="status">Showing 24 results</div> updates as the user filters.
  • Form validation summary — after a failed submit, populate <div role="alert"> with the error count and let screen reader read it.
  • Auto-saving indicator — <div role="status">Saving... Saved at 3:42 PM</div> updates during background saves.
  • Real-time data updates — chat messages, stock prices: aria-live="polite" so the user hears them when convenient.
Show full SKILL.md (505 more words)Show less
Don't overdo announcements

Every announcement steals attention. Frequent live-region updates make the UI noisy for screen reader users. Rules of thumb:

  • Don't announce hover state changes.
  • Don't announce loading spinners (unless the load is unusually long).
  • Don't announce purely cosmetic transitions.
  • Aggregate where possible: instead of "Filter applied," "24 results loaded," "Filter applied," "12 results loaded" with each filter change, debounce and announce only the final state.
aria-atomic and aria-relevant

Fine-tuning live region behavior:

  • aria-atomic="true" — read the entire region content when any part changes (default for role="alert"; useful for counts that should always be read in context: "24 results" changing to "12 results").
  • aria-relevant — control which mutation types announce (default is additions text). Rarely needed.

Worked examples

Example 1: a custom slider built right
html
<label id="volume-label">Volume: <span id="volume-value">50</span>%</label>
<div role="slider"
     aria-labelledby="volume-label"
     aria-valuemin="0"
     aria-valuemax="100"
     aria-valuenow="50"
     tabindex="0"
     id="volume-slider"
     class="slider-track">
  <div class="slider-thumb" style="left: 50%;"></div>
</div>

Plus JavaScript:

  • ArrowLeft/ArrowRight and Home/End adjust value.
  • On adjustment, update aria-valuenow and the visible text (#volume-value).

The native <input type="range"> does all of this automatically — strongly prefer that. Custom sliders are justified only when range can't meet your needs (multi-handle range, custom geometry, color picker).

Example 2: a search results announcement
html
<form>
  <label for="search">Search</label>
  <input id="search" oninput="runSearch(this.value)" />
</form>

<div id="results">…rendered results…</div>
<div id="results-status" class="sr-only" role="status"></div>

<script>
  function runSearch(q) {
    const results = doSearch(q);
    renderResults(results);
    document.getElementById('results-status').textContent =
      `${results.length} results for "${q}"`;
  }
</script>

Sighted users see results below the input; screen reader users hear "24 results for 'invoice'" without focus moving.

Example 3: a toast that announces
html
<div id="toast-region" aria-live="polite" aria-atomic="true" class="sr-only"></div>

<script>
  function showToast(message) {
    const region = document.getElementById('toast-region');
    region.textContent = message;
    showVisualToast(message); // separate visible UI
    setTimeout(() => region.textContent = '', 5000);
  }
</script>

The visible toast is rendered however your design library does it. The hidden live region is what assistive tech uses.

Anti-patterns

  • <div> for everything. A UI built without semantic elements is opaque to assistive tech and requires comprehensive ARIA to recover.
  • role="button" on a <button>. Redundant; sometimes interferes with native behavior.
  • aria-label that contradicts visible text. Voice control breaks; user says "click [visible text]" and nothing happens.
  • Live regions added at announcement time. <div aria-live="polite"> must be in the DOM at page load to be reliably observed; adding it dynamically often misses the announcement.
  • Aria-live on too much content. Page-wide aria-live regions are constantly chattering. Scope to just the announcement element.
  • Custom dropdowns missing keyboard. ARIA roles applied to a div but no Tab, Esc, or arrow-key handlers. The screen reader hears "menu" but the user can't operate it.
  • role="presentation" on tables of data. Strips the semantics that make the table navigable. Reserve for genuinely-decorative table-shaped layouts.

Heuristics

  1. The "is there a native element for this?" check. Before reaching for ARIA, ask if HTML provides what you need. Almost always.
  2. The accessibility tree audit. Chrome DevTools → Accessibility tab. Inspect any custom component. Does it have a name, role, and (where applicable) value? If "name: empty" or "role: generic," the component is invisible to assistive tech.
  3. The screen-reader walkthrough. Open VoiceOver / NVDA / TalkBack and walk a critical flow. Listen for: unlabeled controls, components with no role, changes that aren't announced, "blank" or "press button to" without context.
  4. The HTML validator. Run your most-complex pages through validator.w3.org. Duplicate IDs, nested interactive elements, and missing labels often surface here first.
  • accessibility (parent).
  • accessibility-perceivable, accessibility-operable, accessibility-understandable — siblings.
  • feedback-loop (interaction) — live regions are accessibility's version of feedback.
  • structural-forms (process) — semantic HTML is the structural-forms answer for accessibility.
  • affordance (interaction) — semantic elements come with default affordances.

© hashgraph-online, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in plugins/HDeibler/universal-design-principles/plugins/process-and-robustness-principles/skills/accessibility-robust of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • references/robust-deep-dive.md

Open the folder on GitHubat commit 9e7b281

Compare with similar skills

Accessibility Robust next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Accessibility Robust compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Accessibility Robust this skillhashgraph-online/awesome-codex-plugins1.3k—~3.4kAutomated safety check: PassApache-2.0
Web Interface Guidelines Reviewervercel-labs/openreview1.7k97 repos~308Automated safety check: PassNone
Accessibility Reviewmarkmead/hyperui12k1 repos~1.1kAutomated safety check: PassMIT
Web Animation DesignbaptisteArno/typebot.io11k2 repos~2.7kAutomated safety check: PassCustom licence
Accessibility Fixeribelick/ui-skills9.5k4 repos~1.2kAutomated safety check: PassMIT
Wcag Audit PatternsvmDeshpande/ai-agent-automation17811 repos~610Automated safety check: PassApache-2.0

Similar skills

  • Web Interface Guidelines Reviewer

    vercel-labs/openreview

    Official

    Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my…

    1.7k GitHub starsUsed in 97 repos~308 tokens
    Frontend & DesignAuto-check passed
  • Accessibility Review

    markmead/hyperui

    Run a WCAG 2.1 AA accessibility audit on a design or page. An agent skill from markmead/hyperui.

    12k GitHub starsUsed in 1 repo~1.1k tokens
    Frontend & DesignAuto-check passed
  • Web Animation Design

    baptisteArno/typebot.io

    Guides easing, timing and animation choices for UI motion, based on a web animation course, and reviews existing animations in a before-and-after table.

    11k GitHub starsUsed in 2 repos~2.7k tokens
    Frontend & DesignAuto-check passed
  • Accessibility Fixer

    ibelick/ui-skills

    Audits and fixes HTML accessibility problems such as ARIA labels, keyboard navigation, focus management, contrast and form errors with minimal changes.

    9.5k GitHub starsUsed in 4 repos~1.2k tokens
    Frontend & DesignAuto-check passed
  • Wcag Audit Patterns

    vmDeshpande/ai-agent-automation

    Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance.

    178 GitHub starsUsed in 11 repos~610 tokens
    Frontend & DesignAuto-check passed
  • Baseline UI

    ibelick/ui-skills

    Applies a fixed set of UI rules for stack, components, interaction, animation, typography and layout, or reviews a file against them with concrete fixes.

    9.5k GitHub starsUsed in 8 repos~855 tokens
    Frontend & DesignAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 714 skills in this repo
  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.3k GitHub stars~922 tokensUpdated today
    Auto-check passed
  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.3k GitHub stars~1k tokensUpdated today
    Auto-check passed
  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.3k GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.3k GitHub stars~2.4k tokensUpdated today
    Auto-check passed
  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.3k GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.3k GitHub stars~618 tokensUpdated today
    Auto-check passed

Questions about Accessibility Robust

What does Accessibility Robust do?

A skill your agent uses when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI. Accessibility Robust is an agent skill from hashgraph-online/awesome-codex-plugins. Use this skill when the question is whether assistive technologies — screen readers, voice control, switch devices, refreshable braille displays — can reliably interpret your UI.

When should I use Accessibility Robust?

Accessibility Robust fits situations like: the question is whether assistive technologies — screen readers; refreshable braille displays — can reliably interpret your UI; picking between semantic HTML and a custom-built component; reaching for ARIA.

How do I install Accessibility Robust in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill accessibility-robust -a claude-code`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/process-and-robustness-principles/skills/accessibility-robust in hashgraph-online/awesome-codex-plugins) into .claude/skills/accessibility-robust in your project. Claude Code loads it when a task matches its description.

How do I install Accessibility Robust in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill accessibility-robust -a codex`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/process-and-robustness-principles/skills/accessibility-robust in hashgraph-online/awesome-codex-plugins) into .agents/skills/accessibility-robust in your project. Codex loads it when a task matches its description.

Can I use Accessibility Robust in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hashgraph-online/awesome-codex-plugins --skill accessibility-robust -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/accessibility-robust, .gemini/skills/accessibility-robust, .github/skills/accessibility-robust and .opencode/skills/accessibility-robust in your project.

What does Accessibility Robust need to run?

SKILL.md names no scripts, command-line tools or credentials: Accessibility Robust is instructions for the agent only.

Does Accessibility Robust access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Accessibility Robust safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Accessibility Robust use?

Accessibility Robust is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Accessibility Robust use?

About 3.4k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.6k tokens, read only when the agent opens those files.

What are the alternatives to Accessibility Robust?

Skills that share tags, products or a category with Accessibility Robust: Web Interface Guidelines Reviewer (vercel-labs/openreview, 1.7k stars), Accessibility Review (markmead/hyperui, 12k stars), Web Animation Design (baptisteArno/typebot.io, 11k stars) and Accessibility Fixer (ibelick/ui-skills, 9.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Accessibility Robust?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,255 GitHub stars. The repository holds 714 skills in this directory. The repository was last updated on October 9, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.