textprov 0.1.0 → 0.1.2

data/lib/textprov/core.rb

@@ -4,56 +4,22 @@
 
 require "cgi"
 require "json"
+require "set"
+
+require_relative "grapheme"
 
 module Textprov
-  CONTRACT_VERSION = 1
-  GENERATED_STATES = %w[human ai mixed].freeze
-  PROPOSED_STATES  = %w[edited unknown].freeze
+  SPEC_VERSION = "0.2" # Legacy API name; experimental baseline identifier.
+  UNICODE_VERSION = UCD::UNICODE_VERSION
+  GENERATED_STATES = %w[human ai].freeze
 
   MAPPING_PATH = File.expand_path("mapping.json", __dir__)
 
-  ZWJ  = 0x200D
-  VS15 = 0xFE0E
-  VS16 = 0xFE0F
-  SKIN_TONES = (0x1F3FB..0x1F3FF)
-  REGIONAL   = (0x1F1E6..0x1F1FF)
-
-  # Categories Mn/Mc/Me: extracted from Unicode data. Ruby's regexp \p{Mn} etc.
-  # covers this; using a regex avoids shipping our own category table.
-  COMBINING_RE = /[\p{Mn}\p{Mc}\p{Me}]/
-
   module_function
 
-  def is_combining(char)
-    !!(char =~ COMBINING_RE)
-  end
-
-  # A cluster is a base character plus everything that visually belongs to it:
-  # combining marks, VS15/VS16, skin-tone modifiers, ZWJ joins, and the second
-  # half of a regional-indicator pair. A provenance selector always ends the
-  # cluster.
-  def cluster_end(chars, start, sel_cps)
-    index = start + 1
-    if REGIONAL.include?(chars[start].ord) &&
-       index < chars.length &&
-       REGIONAL.include?(chars[index].ord)
-      index += 1
-    end
-    while index < chars.length
-      cp = chars[index].ord
-      break if sel_cps.include?(cp)
-
-      if cp == ZWJ
-        index += (index + 1 < chars.length ? 2 : 1)
-        next
-      end
-      if cp == VS15 || cp == VS16 || SKIN_TONES.include?(cp) || is_combining(chars[index])
-        index += 1
-        next
-      end
-      break
-    end
-    index
+  # Split `text` into extended grapheme clusters, the units a selector marks.
+  def segments(text)
+    Grapheme.segments(text)
   end
 
   class Mapping
@@ -97,6 +63,11 @@ module Textprov
     attr_writer :default_mapping
   end
 
+  # Exact Unicode White_Space set used by the experiment, independent of runtime predicates.
+  def blank?(text)
+    text.match?(/\A[\u0009-\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+\z/)
+  end
+
   # `text` is a String; we work over its per-codepoint characters. Ruby's
   # String#chars yields one Unicode scalar per element, which is what the
   # Python port iterates.
@@ -113,34 +84,27 @@ module Textprov
     out
   end
 
+  # Implements the decoder algorithm in the baseline experiment: segment into
+  # extended grapheme clusters, classify each cluster, then merge.
   def _runs(text, selectors, pua2base, strip: false, merge_whitespace: true)
-    sel_cps = selectors.values.to_set
     sel2name = selectors.each_with_object({}) { |(name, cp), h| h[cp] = name }
-    chars = text.chars
     items = []
-    index = 0
-    while index < chars.length
-      char = chars[index]
-      cp = char.ord
-      if pua2base.key?(cp)
-        base_cp, state = pua2base[cp]
-        out = strip ? base_cp.chr(Encoding::UTF_8) : base_cp.chr(Encoding::UTF_8) + selectors[state].chr(Encoding::UTF_8)
-        index += 1
-      elsif char.match?(/\s/)
-        state = "ws"
-        out = char
-        index += 1
-      else
-        endi = cluster_end(chars, index, sel_cps)
-        cluster = chars[index...endi].join
-        state = nil
-        out = cluster
-        index = endi
-        if index < chars.length && sel_cps.include?(chars[index].ord)
-          state = sel2name[chars[index].ord]
-          out += chars[index] unless strip
-          index += 1
+    segments(text).each do |cluster|
+      last = cluster[-1].ord
+      state = nil
+      out = cluster
+      if sel2name.key?(last) && cluster.length > 1
+        # Whitespace cannot carry a mark; a selector after it is inert.
+        unless blank?(cluster[0...-1])
+          state = sel2name[last]
+          out = cluster[0...-1] if strip
         end
+      elsif cluster.length == 1 && pua2base.key?(cluster.ord)
+        base_cp, state = pua2base[cluster.ord]
+        out = base_cp.chr(Encoding::UTF_8)
+        out += selectors[state].chr(Encoding::UTF_8) unless strip
+      elsif blank?(cluster)
+        state = "ws"
       end
       if !items.empty? && items.last[0] == state
         items.last[1] << out
@@ -166,8 +130,23 @@ module Textprov
     merged.map { |state, out| [state, out] }
   end
 
-  def _to_html(text, selectors, pua2base, strip: false, merge_whitespace: true,
-               class_prefix: "prov")
+  def _to_html(text, selectors, pua2base, strip: false, merge_whitespace: false,
+               class_prefix: "prov", display: "passage")
+    raise ArgumentError, "display must be 'passage' or 'exact'" unless ["passage", "exact"].include?(display)
+    if display == "passage"
+      return text.split(/((?:\r?\n[ \t]*){2,}|\u2029)/, -1).map do |paragraph|
+        exact = _runs(paragraph, selectors, pua2base, strip: strip, merge_whitespace: false)
+        states = exact.map(&:first).compact.uniq.sort
+        content = _to_html(paragraph, selectors, pua2base, strip: strip,
+                           merge_whitespace: false, class_prefix: class_prefix, display: "exact")
+        if states.empty?
+          content
+        else
+          kind = states.length == 1 ? states.first : "mixed"
+          %(<span class="#{class_prefix}-passage" data-prov-passage="#{kind}">#{content}</span>)
+        end
+      end.join
+    end
     parts = []
     _runs(text, selectors, pua2base, strip: strip,
                                      merge_whitespace: merge_whitespace).each do |state, out|
@@ -181,8 +160,8 @@ module Textprov
     parts.join
   end
 
-  # Public API accepts either merge_whitespace (contract spelling) or
-  # mergeWhitespace (camelCase alias per SPEC's cross-language rule).
+  # Public API accepts either merge_whitespace (snake_case spelling) or
+  # mergeWhitespace (camelCase alias per the experimental cross-language API).
   def runs(text, mapping: nil, strip: false, merge_whitespace: nil, mergeWhitespace: nil)
     mw = if merge_whitespace.nil?
            mergeWhitespace.nil? || mergeWhitespace
@@ -194,15 +173,15 @@ module Textprov
   end
 
   def to_html(text, mapping: nil, strip: false, merge_whitespace: nil, mergeWhitespace: nil,
-              class_prefix: "prov")
+              class_prefix: "prov", display: "passage")
     mw = if merge_whitespace.nil?
-           mergeWhitespace.nil? || mergeWhitespace
+           mergeWhitespace.nil? ? false : mergeWhitespace
          else
            merge_whitespace
          end
     m = mapping || default_mapping
     _to_html(text, m.selectors, m.pua2base, strip: strip, merge_whitespace: mw,
-                                            class_prefix: class_prefix)
+                                            class_prefix: class_prefix, display: display)
   end
 
   def strip_marks(text, mapping: nil)

data/lib/textprov/display.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Textprov
+  module_function
+
+  # Return the shared gradient-mist and dotted-underline CSS as UTF-8 text.
+  def stylesheet
+    File.read(File.join(__dir__, "textprov.css"), encoding: "UTF-8")
+  end
+end

data/lib/textprov/encode.rb

@@ -7,32 +7,26 @@ require_relative "core"
 module Textprov
   module_function
 
+  # Attach the selector for `state` after every markable cluster. Whitespace,
+  # control-break clusters, clusters ending in a provenance selector, lone selectors, and
+  # PUA provenance characters are left alone, so the operation is idempotent.
   def _mark(text, state, mode, selectors, pua2base, base2pua)
+    raise ArgumentError, "invalid provenance state: #{state.inspect}" unless GENERATED_STATES.include?(state)
+
     sel_cps = selectors.values.to_set
     selector = selectors[state].chr(Encoding::UTF_8)
-    chars = text.chars
     out = String.new(encoding: "UTF-8")
-    index = 0
-    while index < chars.length
-      char = chars[index]
-      cp = char.ord
-      if sel_cps.include?(cp) || pua2base.key?(cp) || char.match?(/\s/)
-        out << char
-        index += 1
-        next
-      end
-      start = index
-      index = cluster_end(chars, index, sel_cps)
-      cluster = chars[start...index]
-      if index < chars.length && sel_cps.include?(chars[index].ord)
-        cluster.each { |c| out << c }
-        next
-      end
-      if mode == "pua" && state == "ai" && cluster.length == 1 && base2pua.key?(cp)
-        out << base2pua[cp].chr(Encoding::UTF_8)
+    segments(text).each do |cluster|
+      first = cluster[0].ord
+      last = cluster[-1].ord
+      single = cluster.length == 1
+      if sel_cps.include?(last) || (single && pua2base.key?(first)) || blank?(cluster) ||
+         Grapheme.control_like?(last)
+        out << cluster
+      elsif mode == "pua" && state == "ai" && single && base2pua.key?(first)
+        out << base2pua[first].chr(Encoding::UTF_8)
       else
-        cluster.each { |c| out << c }
-        out << selector
+        out << cluster << selector
       end
     end
     out
@@ -64,23 +58,20 @@ module Textprov
     return text if from_mode == to_mode
 
     vs_ai = selectors["ai"]
-    chars = text.chars
     out = String.new(encoding: "UTF-8")
     if from_mode == "vs"
-      index = 0
-      while index < chars.length
-        char = chars[index]
-        index += 1
-        if index < chars.length && chars[index].ord == vs_ai && base2pua.key?(char.ord)
-          out << base2pua[char.ord].chr(Encoding::UTF_8)
-          index += 1
+      # Per cluster, not per code point: a base that shares its cluster with
+      # anything but its own selector has no PUA counterpart.
+      segments(text).each do |cluster|
+        if cluster.length == 2 && cluster[1].ord == vs_ai && base2pua.key?(cluster[0].ord)
+          out << base2pua[cluster[0].ord].chr(Encoding::UTF_8)
         else
-          out << char
+          out << cluster
         end
       end
       return out
     end
-    chars.each do |char|
+    text.each_char do |char|
       entry = pua2base[char.ord]
       if entry && entry[1] == "ai"
         out << entry[0].chr(Encoding::UTF_8)
@@ -95,50 +86,41 @@ module Textprov
   def _inspect(text, selectors, pua2base)
     sel2name = selectors.each_with_object({}) { |(name, cp), h| h[cp] = name }
     counts = { "unmarked" => 0, "human" => 0, "ai_vs" => 0, "ai_pua" => 0,
-               "unknown" => 0, "edited" => 0, "mixed" => 0, "whitespace" => 0 }
+               "whitespace" => 0 }
     unrecognised_selectors = []
     unrecognised_pua = []
-    sel_cp_set = selectors.values.to_set
 
     chars = text.chars
-    index = 0
-    while index < chars.length
-      char = chars[index]
-      cp = char.ord
-      index += 1
-      if sel2name.key?(cp)
-        unrecognised_selectors << cp
-        next
-      end
-      if cp.between?(0xE0100, 0xE01EF)
-        unrecognised_selectors << cp
-        next
-      end
-      if pua2base.key?(cp)
-        counts["ai_pua"] += 1
-        next
-      end
-      if cp.between?(0x100000, 0x10FFFD)
-        unrecognised_pua << cp
-        next
-      end
-      if char.match?(/\s/)
+    segments(text).each do |cluster|
+      cp = cluster[0].ord
+      last = cluster[-1].ord
+      if cluster.length == 1
+        if sel2name.key?(cp) || cp.between?(0xE0100, 0xE01EF)
+          unrecognised_selectors << cp # a selector with no base in front of it
+        elsif pua2base.key?(cp)
+          counts["ai_pua"] += 1
+        elsif cp.between?(0x100000, 0x10FFFD)
+          unrecognised_pua << cp
+        elsif blank?(cluster)
+          counts["whitespace"] += 1
+        else
+          counts["unmarked"] += 1
+        end
+      elsif sel2name.key?(last) && blank?(cluster[0...-1])
+        counts["whitespace"] += 1 # whitespace cannot carry a mark
+        unrecognised_selectors << last
+      elsif sel2name.key?(last)
+        name = sel2name[last]
+        counts[name == "ai" ? "ai_vs" : name] += 1
+      elsif blank?(cluster)
         counts["whitespace"] += 1
-        next
-      end
-      index = cluster_end(chars, index - 1, sel_cp_set)
-      if index < chars.length && sel_cp_set.include?(chars[index].ord)
-        name = sel2name[chars[index].ord]
-        index += 1
-        key = name == "ai" ? "ai_vs" : name
-        counts[key] += 1
       else
         counts["unmarked"] += 1
       end
     end
 
     lines = ["characters: #{chars.length}"]
-    %w[unmarked human ai_vs ai_pua unknown edited mixed whitespace].each do |key|
+    %w[unmarked human ai_vs ai_pua whitespace].each do |key|
       lines << "#{key}: #{counts[key]}"
     end
     sels = unrecognised_selectors.uniq.sort.map { |cp| format("U+%04X", cp) }.join(" ")

data/lib/textprov/grapheme.rb

@@ -0,0 +1,129 @@
+# ruby/lib/textprov/grapheme.rb
+#
+# frozen_string_literal: true
+
+require_relative "ucd"
+
+module Textprov
+  # Extended grapheme cluster segmentation (UAX #29).
+  #
+  # The segmenter reads the property tables in ucd.rb, generated from one
+  # pinned Unicode version, instead of the Unicode version Onigmo ships with
+  # the interpreter. Every port segments from the same tables, so a cluster
+  # marked by one decodes as one cluster in the others. Rule numbers below
+  # refer to UAX #29, Grapheme Cluster Boundary Rules.
+  module Grapheme
+    CR = UCD::GCB["CR"]
+    LF = UCD::GCB["LF"]
+    CONTROL = UCD::GCB["Control"]
+    EXTEND = UCD::GCB["Extend"]
+    ZWJ = UCD::GCB["ZWJ"]
+    RI = UCD::GCB["Regional_Indicator"]
+    PREPEND = UCD::GCB["Prepend"]
+    SPACING_MARK = UCD::GCB["SpacingMark"]
+    L = UCD::GCB["L"]
+    V = UCD::GCB["V"]
+    T = UCD::GCB["T"]
+    LV = UCD::GCB["LV"]
+    LVT = UCD::GCB["LVT"]
+    CONTROL_LIKE = [CONTROL, CR, LF].freeze
+    AFTER_L = [L, V, LV, LVT].freeze
+    BEFORE_V = [LV, V].freeze
+    V_OR_T = [V, T].freeze
+    BEFORE_T = [LVT, T].freeze
+    EXTENDING = [EXTEND, ZWJ, SPACING_MARK].freeze
+    CONSONANT = UCD::INCB["Consonant"]
+    LINKER = UCD::INCB["Linker"]
+    INCB_EXTEND = UCD::INCB["Extend"]
+    EXTENDED_PICTOGRAPHIC = UCD::EXTENDED_PICTOGRAPHIC
+    GCB_MASK = 15
+    INCB_MASK = 224
+
+    # The look-behind a boundary decision needs beyond the previous code
+    # point: how many regional indicators precede it, whether an emoji ZWJ
+    # sequence is open (GB11), and whether an Indic conjunct is open (GB9c).
+    State = Struct.new(:regional_run, :pictograph, :conjunct)
+
+    module_function
+
+    # The property byte for one code point.
+    def property(codepoint)
+      index = UCD::BOUNDS.bsearch_index { |bound| bound > codepoint }
+      UCD::CODES[index ? index - 1 : -1]
+    end
+
+    # GB4 forces a break after these code points, even before Extend.
+    def control_like?(codepoint)
+      CONTROL_LIKE.include?(property(codepoint) & GCB_MASK)
+    end
+
+    # Split `text` into extended grapheme clusters.
+    def segments(text)
+      clusters = []
+      return clusters if text.empty?
+
+      chars = text.chars
+      current = chars[0].dup
+      previous = property(chars[0].ord)
+      state = advance(State.new(0, 0, 0), previous)
+      chars[1..].each do |character|
+        following = property(character.ord)
+        if join?(previous, following, state)
+          current << character
+        else
+          clusters << current
+          current = character.dup
+        end
+        state = advance(state, following)
+        previous = following
+      end
+      clusters << current
+      clusters
+    end
+
+    # Is there no boundary between a code point with property byte `previous`
+    # and one with `following`? One guard per rule, in rule order.
+    def join?(previous, following, state) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      before = previous & GCB_MASK
+      after = following & GCB_MASK
+      return true if before == CR && after == LF # GB3
+      return false if CONTROL_LIKE.include?(before) || CONTROL_LIKE.include?(after) # GB4, GB5
+      return true if before == L && AFTER_L.include?(after) # GB6
+      return true if BEFORE_V.include?(before) && V_OR_T.include?(after) # GB7
+      return true if BEFORE_T.include?(before) && after == T # GB8
+      return true if EXTENDING.include?(after) # GB9, GB9a
+      return true if before == PREPEND # GB9b
+      return true if state.conjunct == 2 && (following & INCB_MASK) == CONSONANT # GB9c
+      return true if state.pictograph == 2 && following.anybits?(EXTENDED_PICTOGRAPHIC) # GB11
+      return state.regional_run.odd? if before == RI && after == RI # GB12, GB13
+
+      false # GB999
+    end
+
+    # The state after consuming a code point with property byte `following`.
+    def advance(state, following)
+      gcb = following & GCB_MASK
+      regional_run = gcb == RI ? state.regional_run + 1 : 0
+      # 0: nothing; 1: Extended_Pictographic Extend*; 2: that followed by ZWJ.
+      open = state.pictograph == 1
+      pictograph =
+        if following.anybits?(EXTENDED_PICTOGRAPHIC) || (open && gcb == EXTEND) then 1
+        elsif open && gcb == ZWJ then 2
+        else 0
+        end
+      # 0: nothing; 1: Consonant (Extend|Linker)* without a Linker yet;
+      # 2: Consonant ... Linker (Extend|Linker)*.
+      incb = following & INCB_MASK
+      conjunct = conjunct_after(state.conjunct, incb)
+      State.new(regional_run, pictograph, conjunct)
+    end
+
+    def conjunct_after(conjunct, incb)
+      return 1 if incb == CONSONANT
+      return 0 if conjunct.zero?
+      return 2 if incb == LINKER
+
+      incb == INCB_EXTEND ? conjunct : 0
+    end
+  end
+end

data/lib/textprov/mapping.json

@@ -1,11 +1,8 @@
 {
-  "version": 1,
+  "version": "0.2",
   "variation_selectors": {
     "human": "U+E0100",
-    "ai": "U+E0101",
-    "mixed": "U+E0102",
-    "edited": "U+E0103",
-    "unknown": "U+E0104"
+    "ai": "U+E0101"
   },
   "pua": {
     "U+100021": {

data/lib/textprov/textprov.css

@@ -0,0 +1,151 @@
+/* js/textprov.css */
+
+/*
+ * Optional styles for the TextProv baseline demonstration.
+ * Classifications are human and ai; these styles do not implement voice references.
+ * Mapping: ../experiments/baseline/mapping.json (experimental version 0.2).
+ * Applications may choose other presentation without changing the stored text.
+ * The reveal treatment is gradient mist with an 80%-strength dotted underline.
+ * The former wavy/sawtooth provenance underline is obsolete.
+ */
+
+/* Native application annotations remain above the optional reveal layer. */
+@layer textprov {
+
+:root {
+  --prov-human-bg: rgba(46, 160, 67, 0.14);
+  --prov-human-line: #2ea043;
+  --prov-ai-bg: rgba(199, 125, 0, 0.14);
+  --prov-ai-line: #c77d00;
+  --prov-mixed-line: #6e7781;
+  --prov-mixed-bg: rgba(110, 119, 129, 0.14);
+  --prov-tint: 14%;
+  --prov-dot-strength: 80%;
+  --prov-glow-opacity: 27%;
+  --prov-glow-blur: 11.2px;
+  --prov-glow-spread: 4px;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --prov-human-bg: rgba(63, 185, 80, 0.16);
+    --prov-human-line: #3fb950;
+    --prov-ai-bg: rgba(227, 152, 33, 0.16);
+    --prov-ai-line: #e39821;
+    --prov-mixed-line: #a0a7b0;
+    --prov-mixed-bg: rgba(160, 167, 176, 0.16);
+    --prov-glow-opacity: 17.55%;
+  }
+}
+
+.prov,
+.prov-human,
+.prov-ai,
+[data-prov="human"],
+[data-prov="ai"],
+[data-prov-passage] {
+  /* No border/padding/margin/line-height: marks must not affect layout. */
+  box-decoration-break: clone;
+  -webkit-box-decoration-break: clone;
+  border-radius: 3px;
+}
+
+.prov-human,
+[data-prov="human"],
+[data-prov-passage="human"] {
+  --prov-color: var(--prov-human-line);
+  --prov-fallback-bg: var(--prov-human-bg);
+}
+
+.prov-ai,
+[data-prov="ai"],
+[data-prov-passage="ai"] {
+  --prov-color: var(--prov-ai-line);
+  --prov-fallback-bg: var(--prov-ai-bg);
+}
+
+.prov-human,
+.prov-ai,
+[data-prov="human"],
+[data-prov="ai"],
+[data-prov-passage] {
+  /* The solid tint is a fallback for engines without color-mix(). */
+  background: var(--prov-fallback-bg);
+}
+
+:is(.prov-human, .prov-ai, [data-prov="human"], [data-prov="ai"], [data-prov-passage]):not(a) {
+  text-decoration-line: underline;
+  text-decoration-style: dotted;
+  text-decoration-color: var(--prov-color);
+  text-decoration-thickness: 1.5px;
+  text-decoration-skip-ink: none;
+  text-underline-offset: 5px;
+}
+
+@supports (background: color-mix(in srgb, currentColor 50%, transparent)) {
+  .prov-human,
+  .prov-ai,
+  [data-prov="human"],
+  [data-prov="ai"],
+  [data-prov-passage] {
+    background: linear-gradient(
+      115deg,
+      color-mix(in srgb, var(--prov-color) calc(var(--prov-tint) * 0.45), transparent),
+      color-mix(in srgb, var(--prov-color) calc(var(--prov-tint) * 1.6), transparent) 55%,
+      color-mix(in srgb, var(--prov-color) calc(var(--prov-tint) * 0.6), transparent)
+    );
+    box-shadow: 0 0 var(--prov-glow-blur) var(--prov-glow-spread)
+      color-mix(in srgb, var(--prov-color) var(--prov-glow-opacity), transparent);
+  }
+
+  :is(.prov-human, .prov-ai, [data-prov="human"], [data-prov="ai"], [data-prov-passage]):not(a) {
+    text-decoration-color: color-mix(in srgb, var(--prov-color) var(--prov-dot-strength), transparent);
+  }
+}
+
+/* A group describes a passage containing marks, not every character's origin. */
+[data-prov-passage="mixed"] {
+  --prov-color: var(--prov-mixed-line);
+  --prov-fallback-bg: var(--prov-mixed-bg);
+}
+
+/* Exact spans always remain in the DOM. Only the chosen display layer paints. */
+[data-prov-passage] [data-prov]:not([data-prov-display="exact"] *),
+[data-prov-display="exact"] [data-prov-passage] {
+  background: none;
+  box-shadow: none;
+  text-decoration: none;
+}
+
+/* Existing link underlines keep their channel. For spelling/grammar cues,
+ * put data-prov-decoration="native" on the enclosing proofing range. */
+a :is(.prov, [data-prov="human"], [data-prov="ai"], [data-prov-passage]),
+[data-prov-decoration="native"] :is(.prov, [data-prov="human"], [data-prov="ai"], [data-prov-passage]):not(a),
+:is(.prov, [data-prov="human"], [data-prov="ai"], [data-prov-passage])[data-prov-decoration="native"]:not(a) {
+  text-decoration: none;
+}
+
+[data-prov-passage]:has([data-prov-decoration="native"]) { text-decoration: none; }
+
+/* Comment anchors and other native fills can retain their own background. */
+[data-prov-background="native"] :is(.prov, [data-prov="human"], [data-prov="ai"], [data-prov-passage]),
+:is(.prov, [data-prov="human"], [data-prov="ai"], [data-prov-passage])[data-prov-background="native"] {
+  background: none;
+  box-shadow: none;
+}
+
+[data-prov-passage]:has([data-prov-background="native"]) { background: none; box-shadow: none; }
+
+@media (forced-colors: active) {
+  .prov-human,
+  .prov-ai,
+  [data-prov="human"],
+  [data-prov="ai"],
+  [data-prov-passage] {
+    background: none;
+    box-shadow: none;
+    text-decoration-color: currentColor;
+  }
+}
+
+}