@akiojin/gwt 9.6.0 → 9.8.0

package/scripts/test_release_assets.cjs

@@ -6,7 +6,9 @@ const { execFileSync } = require("child_process");
 
 const {
   binaryNameForPlatform,
-  installBinaryFromArchive,
+  bundleBinaryNamesForPlatform,
+  installBundleFromArchive,
+  primaryReleaseAssetName,
   releaseAssetName,
 } = require("./release-assets.cjs");
 const postinstall = require("./postinstall.cjs");
@@ -33,63 +35,154 @@ run("release asset names match the public portable contract", () => {
   assert.equal(releaseAssetName("win32", "x64"), "gwt-windows-x86_64.zip");
 });
 
+run("primary release asset names match the GUI-first install contract", () => {
+  assert.equal(primaryReleaseAssetName("darwin", "arm64"), "gwt-macos-universal.dmg");
+  assert.equal(primaryReleaseAssetName("darwin", "x64"), "gwt-macos-universal.dmg");
+  assert.equal(primaryReleaseAssetName("linux", "arm64"), "gwt-linux-aarch64.tar.gz");
+  assert.equal(primaryReleaseAssetName("linux", "x64"), "gwt-linux-x86_64.tar.gz");
+  assert.equal(primaryReleaseAssetName("win32", "x64"), "gwt-windows-x86_64.msi");
+});
+
 run("release helper keeps platform binary names stable", () => {
   assert.equal(binaryNameForPlatform("win32"), "gwt.exe");
   assert.equal(binaryNameForPlatform("linux"), "gwt");
   assert.equal(binaryNameForPlatform("darwin"), "gwt");
 });
 
+run("release helper keeps bundle binary names stable", () => {
+  assert.deepEqual(bundleBinaryNamesForPlatform("win32"), ["gwt.exe", "gwtd.exe"]);
+  assert.deepEqual(bundleBinaryNamesForPlatform("linux"), ["gwt", "gwtd"]);
+  assert.deepEqual(bundleBinaryNamesForPlatform("darwin"), ["gwt", "gwtd"]);
+});
+
 run("installer entrypoints are loadable under package type module", () => {
   assert.equal(typeof postinstall.main, "function");
   assert.equal(typeof launcher.main, "function");
 });
 
-run("portable tarball extraction installs the unix binary", () => {
+run("windows installer definition includes the gwtd companion binary", () => {
+  const wix = fs.readFileSync(path.join(__dirname, "..", "wix", "main.wxs"), "utf8");
+  assert.match(wix, /gwtd\.exe/);
+});
+
+run("release workflow packages gwtd alongside gwt", () => {
+  const workflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "release.yml"),
+    "utf8"
+  );
+  assert.match(workflow, /--bin gwt --bin gwtd/);
+  assert.match(workflow, /Compress-Archive -Path @\("dist\/gwt\.exe", "dist\/gwtd\.exe"\)/);
+  assert.match(workflow, /tar -czf \$\{\{ matrix\.archive_name \}\} gwt gwtd/);
+  assert.match(workflow, /Contents\/MacOS\/gwtd/);
+});
+
+run("package scripts keep the GUI front door and release contract explicit", () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+  assert.equal(pkg.scripts["test:release-assets"], "node scripts/test_release_assets.cjs");
+  assert.equal(
+    pkg.scripts["test:frontend-bundle"],
+    "node --check crates/gwt/web/app.js"
+  );
+  assert.equal(pkg.scripts["test:release-flow"], "bash scripts/check-release-flow.sh");
+  assert.equal(pkg.scripts.dev, "cargo run -p gwt --bin gwt");
+  assert.equal(pkg.scripts.build, "cargo build --release -p gwt --bin gwt --bin gwtd");
+});
+
+run("test all script keeps rust tests plus frontend release checks", () => {
+  const testAll = fs.readFileSync(path.join(__dirname, "test-all.sh"), "utf8");
+  assert.match(testAll, /test -p gwt-core -p gwt --all-features/);
+  assert.match(testAll, /cargo\.exe/);
+  assert.match(testAll, /bash scripts\/check-release-flow\.sh/);
+});
+
+run("release flow helper checks the shared frontend bundle and release assets", () => {
+  const releaseFlow = fs.readFileSync(path.join(__dirname, "check-release-flow.sh"), "utf8");
+  assert.match(releaseFlow, /scripts\/test_release_assets\.cjs/);
+  assert.match(releaseFlow, /node --check \"\$APP_JS\"/);
+  assert.match(releaseFlow, /script type=\"module\" src=\"\/app\.js\"/);
+});
+
+run("CI workflows call the named frontend and release verification scripts", () => {
+  const lintWorkflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "lint.yml"),
+    "utf8"
+  );
+  const testWorkflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "test.yml"),
+    "utf8"
+  );
+
+  assert.match(lintWorkflow, /test:frontend-bundle/);
+  assert.match(lintWorkflow, /test:release-flow/);
+  assert.match(testWorkflow, /test:release-assets/);
+});
+
+run("README install guidance points to GUI-first release assets", () => {
+  const readme = fs.readFileSync(path.join(__dirname, "..", "README.md"), "utf8");
+  const readmeJa = fs.readFileSync(path.join(__dirname, "..", "README.ja.md"), "utf8");
+
+  for (const doc of [readme, readmeJa]) {
+    assert.match(doc, /gwt-macos-universal\.dmg/);
+    assert.match(doc, /gwt-windows-x86_64\.msi/);
+    assert.match(doc, /gwt-linux-x86_64\.tar\.gz/);
+    assert.match(doc, /test:frontend-bundle|node --check crates\/gwt\/web\/app\.js/);
+    assert.match(doc, /test:release-flow|bash scripts\/check-release-flow\.sh/);
+  }
+});
+
+run("portable tarball extraction installs the unix bundle", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
   const sourceDir = path.join(root, "source");
   const binDir = path.join(root, "bin");
   const archivePath = path.join(root, "gwt-linux-x86_64.tar.gz");
   fs.mkdirSync(sourceDir, { recursive: true });
   fs.writeFileSync(path.join(sourceDir, "gwt"), "unix-binary");
+  fs.writeFileSync(path.join(sourceDir, "gwtd"), "unix-daemon");
 
-  execFileSync("tar", ["-czf", archivePath, "-C", sourceDir, "gwt"]);
+  execFileSync("tar", ["-czf", archivePath, "-C", sourceDir, "gwt", "gwtd"]);
 
-  installBinaryFromArchive({
+  installBundleFromArchive({
     archivePath,
     asset: path.basename(archivePath),
     binDir,
-    binaryName: "gwt",
     platform: "linux",
   });
 
   assert.equal(fs.readFileSync(path.join(binDir, "gwt"), "utf8"), "unix-binary");
+  assert.equal(fs.readFileSync(path.join(binDir, "gwtd"), "utf8"), "unix-daemon");
 });
 
-run("portable zip extraction installs the windows binary", () => {
+run("portable zip extraction installs the windows bundle", () => {
+  if (process.platform !== "win32") {
+    return;
+  }
+
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
   const sourceDir = path.join(root, "source");
   const binDir = path.join(root, "bin");
   const archivePath = path.join(root, "gwt-windows-x86_64.zip");
   const sourceBinary = path.join(sourceDir, "gwt.exe");
+  const sourceDaemon = path.join(sourceDir, "gwtd.exe");
   fs.mkdirSync(sourceDir, { recursive: true });
   fs.writeFileSync(sourceBinary, "windows-binary");
+  fs.writeFileSync(sourceDaemon, "windows-daemon");
 
   execFileSync("powershell.exe", [
     "-NoProfile",
     "-NonInteractive",
     "-Command",
-    `Compress-Archive -LiteralPath '${sourceBinary.replace(/'/g, "''")}' -DestinationPath '${archivePath.replace(/'/g, "''")}' -Force`,
+    `Compress-Archive -LiteralPath @('${sourceBinary.replace(/'/g, "''")}','${sourceDaemon.replace(/'/g, "''")}') -DestinationPath '${archivePath.replace(/'/g, "''")}' -Force`,
   ]);
 
-  installBinaryFromArchive({
+  installBundleFromArchive({
     archivePath,
     asset: path.basename(archivePath),
     binDir,
-    binaryName: "gwt.exe",
     platform: "win32",
   });
 
   assert.equal(fs.readFileSync(path.join(binDir, "gwt.exe"), "utf8"), "windows-binary");
+  assert.equal(fs.readFileSync(path.join(binDir, "gwtd.exe"), "utf8"), "windows-daemon");
 });
 
 if (failed) {

package/scripts/verify-husky-hooks.sh

@@ -43,7 +43,9 @@ require_contains "$PACKAGE_JSON" "\"lint:husky\": \"bash scripts/verify-husky-ho
 require_file "$PRE_PUSH"
 require_contains "$PRE_PUSH" "cargo clippy --all-targets --all-features -- -D warnings"
 require_contains "$PRE_PUSH" "cargo fmt --all -- --check"
-require_contains "$PRE_PUSH" "bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md"
+require_contains "$PRE_PUSH" "cargo llvm-cov -p gwt-core -p gwt --all-features --json --summary-only --output-path target/coverage-summary.json"
+require_contains "$PRE_PUSH" "node scripts/check-coverage-threshold.mjs target/coverage-summary.json 90"
+require_contains "$PRE_PUSH" "bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md --ignore tasks/todo.md"
 require_contains "$PRE_PUSH" "pnpm lint:skills"
 
 require_file "$COMMIT_MSG"
@@ -52,8 +54,6 @@ require_contains "$COMMIT_MSG" 'bunx --package @commitlint/cli commitlint --edit
 if [ -f "$PRE_COMMIT" ]; then
   require_contains "$PRE_COMMIT" "pnpm lint:skills"
   require_contains "$PRE_COMMIT" "bash scripts/run-local-backend-tests-on-commit.sh"
-  require_contains "$PRE_COMMIT" "bash scripts/run-local-e2e-on-commit.sh"
-  require_contains "$PRE_COMMIT" "bash scripts/run-local-e2e-coverage-on-commit.sh"
   require_not_contains "$PRE_COMMIT" "cargo clippy --all-targets --all-features -- -D warnings"
   require_not_contains "$PRE_COMMIT" "cargo fmt --all -- --check"
   require_not_contains "$PRE_COMMIT" "markdownlint-cli"

package/vendor/vt100/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jesse Luehrs
+
+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.

package/vendor/vt100/src/attrs.rs

@@ -0,0 +1,144 @@
+use crate::term::BufWrite as _;
+
+/// Represents a foreground or background color for cells.
+#[derive(Eq, PartialEq, Debug, Copy, Clone, Default)]
+pub enum Color {
+    /// The default terminal color.
+    #[default]
+    Default,
+
+    /// An indexed terminal color.
+    Idx(u8),
+
+    /// An RGB terminal color. The parameters are (red, green, blue).
+    Rgb(u8, u8, u8),
+}
+
+const TEXT_MODE_INTENSITY: u8 = 0b0000_0011;
+const TEXT_MODE_BOLD: u8 = 0b0000_0001;
+const TEXT_MODE_DIM: u8 = 0b0000_0010;
+const TEXT_MODE_ITALIC: u8 = 0b0000_0100;
+const TEXT_MODE_UNDERLINE: u8 = 0b0000_1000;
+const TEXT_MODE_INVERSE: u8 = 0b0001_0000;
+
+#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Attrs {
+    pub fgcolor: Color,
+    pub bgcolor: Color,
+    pub mode: u8,
+}
+
+impl Attrs {
+    pub fn bold(&self) -> bool {
+        self.mode & TEXT_MODE_BOLD != 0
+    }
+
+    pub fn dim(&self) -> bool {
+        self.mode & TEXT_MODE_DIM != 0
+    }
+
+    fn intensity(&self) -> u8 {
+        self.mode & TEXT_MODE_INTENSITY
+    }
+
+    pub fn set_bold(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+        self.mode |= TEXT_MODE_BOLD;
+    }
+
+    pub fn set_dim(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+        self.mode |= TEXT_MODE_DIM;
+    }
+
+    pub fn set_normal_intensity(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+    }
+
+    pub fn italic(&self) -> bool {
+        self.mode & TEXT_MODE_ITALIC != 0
+    }
+
+    pub fn set_italic(&mut self, italic: bool) {
+        if italic {
+            self.mode |= TEXT_MODE_ITALIC;
+        } else {
+            self.mode &= !TEXT_MODE_ITALIC;
+        }
+    }
+
+    pub fn underline(&self) -> bool {
+        self.mode & TEXT_MODE_UNDERLINE != 0
+    }
+
+    pub fn set_underline(&mut self, underline: bool) {
+        if underline {
+            self.mode |= TEXT_MODE_UNDERLINE;
+        } else {
+            self.mode &= !TEXT_MODE_UNDERLINE;
+        }
+    }
+
+    pub fn inverse(&self) -> bool {
+        self.mode & TEXT_MODE_INVERSE != 0
+    }
+
+    pub fn set_inverse(&mut self, inverse: bool) {
+        if inverse {
+            self.mode |= TEXT_MODE_INVERSE;
+        } else {
+            self.mode &= !TEXT_MODE_INVERSE;
+        }
+    }
+
+    pub fn write_escape_code_diff(
+        &self,
+        contents: &mut Vec<u8>,
+        other: &Self,
+    ) {
+        if self != other && self == &Self::default() {
+            crate::term::ClearAttrs.write_buf(contents);
+            return;
+        }
+
+        let attrs = crate::term::Attrs::default();
+
+        let attrs = if self.fgcolor == other.fgcolor {
+            attrs
+        } else {
+            attrs.fgcolor(self.fgcolor)
+        };
+        let attrs = if self.bgcolor == other.bgcolor {
+            attrs
+        } else {
+            attrs.bgcolor(self.bgcolor)
+        };
+        let attrs = if self.intensity() == other.intensity() {
+            attrs
+        } else {
+            attrs.intensity(match self.intensity() {
+                0 => crate::term::Intensity::Normal,
+                TEXT_MODE_BOLD => crate::term::Intensity::Bold,
+                TEXT_MODE_DIM => crate::term::Intensity::Dim,
+                _ => unreachable!(),
+            })
+        };
+        let attrs = if self.italic() == other.italic() {
+            attrs
+        } else {
+            attrs.italic(self.italic())
+        };
+        let attrs = if self.underline() == other.underline() {
+            attrs
+        } else {
+            attrs.underline(self.underline())
+        };
+        let attrs = if self.inverse() == other.inverse() {
+            attrs
+        } else {
+            attrs.inverse(self.inverse())
+        };
+
+        attrs.write_buf(contents);
+    }
+}

package/vendor/vt100/src/callbacks.rs

@@ -0,0 +1,69 @@
+/// This trait is used by the parser to handle extra escape sequences that
+/// don't have an impact on the terminal screen directly.
+pub trait Callbacks {
+    /// This callback is called when the terminal requests an audible bell
+    /// (typically with `^G`).
+    fn audible_bell(&mut self, _: &mut crate::Screen) {}
+    /// This callback is called when the terminal requests a visual bell
+    /// (typically with `\eg`).
+    fn visual_bell(&mut self, _: &mut crate::Screen) {}
+    /// This callback is called when the terminal requests a resize
+    /// (typically with `\e[8;<rows>;<cols>t`).
+    fn resize(&mut self, _: &mut crate::Screen, _request: (u16, u16)) {}
+    /// This callback is called when the terminal requests the window title
+    /// to be set (typically with `\e]1;<icon_name>\a`)
+    fn set_window_icon_name(
+        &mut self,
+        _: &mut crate::Screen,
+        _icon_name: &[u8],
+    ) {
+    }
+    /// This callback is called when the terminal requests the window title
+    /// to be set (typically with `\e]2;<title>\a`)
+    fn set_window_title(&mut self, _: &mut crate::Screen, _title: &[u8]) {}
+    /// This callback is called when the terminal requests data to be copied
+    /// to the system clipboard (typically with `\e]52;<ty>;<data>\a`). Note
+    /// that `data` will be encoded as base64.
+    fn copy_to_clipboard(
+        &mut self,
+        _: &mut crate::Screen,
+        _ty: &[u8],
+        _data: &[u8],
+    ) {
+    }
+    /// This callback is called when the terminal requests data to be pasted
+    /// from the system clipboard (typically with `\e]52;<ty>;?\a`).
+    fn paste_from_clipboard(&mut self, _: &mut crate::Screen, _ty: &[u8]) {}
+    /// This callback is called when the terminal receives an escape sequence
+    /// which is otherwise not implemented.
+    fn unhandled_char(&mut self, _: &mut crate::Screen, _c: char) {}
+    /// This callback is called when the terminal receives a control
+    /// character which is otherwise not implemented.
+    fn unhandled_control(&mut self, _: &mut crate::Screen, _b: u8) {}
+    /// This callback is called when the terminal receives an escape sequence
+    /// which is otherwise not implemented.
+    fn unhandled_escape(
+        &mut self,
+        _: &mut crate::Screen,
+        _i1: Option<u8>,
+        _i2: Option<u8>,
+        _b: u8,
+    ) {
+    }
+    /// This callback is called when the terminal receives a CSI sequence
+    /// (`\e[`) which is otherwise not implemented.
+    fn unhandled_csi(
+        &mut self,
+        _: &mut crate::Screen,
+        _i1: Option<u8>,
+        _i2: Option<u8>,
+        _params: &[&[u16]],
+        _c: char,
+    ) {
+    }
+    /// This callback is called when the terminal receives a OSC sequence
+    /// (`\e]`) which is otherwise not implemented.
+    fn unhandled_osc(&mut self, _: &mut crate::Screen, _params: &[&[u8]]) {}
+}
+
+impl Callbacks for () {}

package/vendor/vt100/src/cell.rs

@@ -0,0 +1,179 @@
+use unicode_width::UnicodeWidthChar as _;
+
+// chosen to make the size of the cell struct 32 bytes
+const CONTENT_BYTES: usize = 22;
+
+const IS_WIDE: u8 = 0b1000_0000;
+const IS_WIDE_CONTINUATION: u8 = 0b0100_0000;
+const LEN_BITS: u8 = 0b0001_1111;
+
+/// Represents a single terminal cell.
+#[derive(Clone, Debug, Eq)]
+pub struct Cell {
+    contents: [u8; CONTENT_BYTES],
+    len: u8,
+    attrs: crate::attrs::Attrs,
+}
+const _: () = assert!(std::mem::size_of::<Cell>() == 32);
+
+impl PartialEq<Self> for Cell {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len != other.len {
+            return false;
+        }
+        if self.attrs != other.attrs {
+            return false;
+        }
+        let len = self.len();
+        self.contents[..len] == other.contents[..len]
+    }
+}
+
+impl Cell {
+    pub(crate) fn new() -> Self {
+        Self {
+            contents: Default::default(),
+            len: 0,
+            attrs: crate::attrs::Attrs::default(),
+        }
+    }
+
+    fn len(&self) -> usize {
+        usize::from(self.len & LEN_BITS)
+    }
+
+    pub(crate) fn set(&mut self, c: char, a: crate::attrs::Attrs) {
+        self.len = 0;
+        self.append_char(0, c);
+        // strings in this context should always be an arbitrary character
+        // followed by zero or more zero-width characters, so we should only
+        // have to look at the first character
+        self.set_wide(c.width().unwrap_or(1) > 1);
+        self.attrs = a;
+    }
+
+    pub(crate) fn append(&mut self, c: char) {
+        let len = self.len();
+        if len >= CONTENT_BYTES - 4 {
+            return;
+        }
+        if len == 0 {
+            self.contents[0] = b' ';
+            self.len += 1;
+        }
+
+        // we already checked that we have space for another codepoint
+        self.append_char(self.len(), c);
+    }
+
+    // Writes bytes representing c at start
+    // Requires caller to verify start <= CODEPOINTS_IN_CELL * 4
+    fn append_char(&mut self, start: usize, c: char) {
+        c.encode_utf8(&mut self.contents[start..]);
+        self.len += u8::try_from(c.len_utf8()).unwrap();
+    }
+
+    pub(crate) fn clear(&mut self, attrs: crate::attrs::Attrs) {
+        self.len = 0;
+        self.attrs = attrs;
+    }
+
+    /// Returns the text contents of the cell.
+    ///
+    /// Can include multiple unicode characters if combining characters are
+    /// used, but will contain at most one character with a non-zero character
+    /// width.
+    // Since contents has been constructed by appending chars encoded as UTF-8 it will be valid UTF-8
+    #[allow(clippy::missing_panics_doc)]
+    #[must_use]
+    pub fn contents(&self) -> &str {
+        std::str::from_utf8(&self.contents[..self.len()]).unwrap()
+    }
+
+    /// Returns whether the cell contains any text data.
+    #[must_use]
+    pub fn has_contents(&self) -> bool {
+        self.len() > 0
+    }
+
+    /// Returns whether the text data in the cell represents a wide character.
+    #[must_use]
+    pub fn is_wide(&self) -> bool {
+        self.len & IS_WIDE != 0
+    }
+
+    /// Returns whether the cell contains the second half of a wide character
+    /// (in other words, whether the previous cell in the row contains a wide
+    /// character)
+    #[must_use]
+    pub fn is_wide_continuation(&self) -> bool {
+        self.len & IS_WIDE_CONTINUATION != 0
+    }
+
+    fn set_wide(&mut self, wide: bool) {
+        if wide {
+            self.len |= IS_WIDE;
+        } else {
+            self.len &= !IS_WIDE;
+        }
+    }
+
+    pub(crate) fn set_wide_continuation(&mut self, wide: bool) {
+        if wide {
+            self.len |= IS_WIDE_CONTINUATION;
+        } else {
+            self.len &= !IS_WIDE_CONTINUATION;
+        }
+    }
+
+    pub(crate) fn attrs(&self) -> &crate::attrs::Attrs {
+        &self.attrs
+    }
+
+    /// Returns the foreground color of the cell.
+    #[must_use]
+    pub fn fgcolor(&self) -> crate::Color {
+        self.attrs.fgcolor
+    }
+
+    /// Returns the background color of the cell.
+    #[must_use]
+    pub fn bgcolor(&self) -> crate::Color {
+        self.attrs.bgcolor
+    }
+
+    /// Returns whether the cell should be rendered with the bold text
+    /// attribute.
+    #[must_use]
+    pub fn bold(&self) -> bool {
+        self.attrs.bold()
+    }
+
+    /// Returns whether the cell should be rendered with the dim text
+    /// attribute.
+    #[must_use]
+    pub fn dim(&self) -> bool {
+        self.attrs.dim()
+    }
+
+    /// Returns whether the cell should be rendered with the italic text
+    /// attribute.
+    #[must_use]
+    pub fn italic(&self) -> bool {
+        self.attrs.italic()
+    }
+
+    /// Returns whether the cell should be rendered with the underlined text
+    /// attribute.
+    #[must_use]
+    pub fn underline(&self) -> bool {
+        self.attrs.underline()
+    }
+
+    /// Returns whether the cell should be rendered with the inverse text
+    /// attribute.
+    #[must_use]
+    pub fn inverse(&self) -> bool {
+        self.attrs.inverse()
+    }
+}