From accc206dd61470a650e619d6c6d3b657baacb241 Mon Sep 17 00:00:00 2001 From: Xuepoo Date: Sat, 26 Sep 2026 08:50:28 +0800 Subject: [PATCH] [CTX-0079] fix(campaign): redact before truncation and bound campaign data --- crates/devtools-client/src/redaction.rs | 447 +- src/campaign.ts | 2005 +++++++- src/redaction.ts | 195 + tests/campaign.test.ts | 1696 ++++++- .../redaction-normalization-class.txt | 4515 +++++++++++++++++ tests/fixtures/redaction-separator-corpus.txt | 2312 +++++++++ 6 files changed, 10812 insertions(+), 358 deletions(-) create mode 100644 tests/fixtures/redaction-normalization-class.txt create mode 100644 tests/fixtures/redaction-separator-corpus.txt diff --git a/crates/devtools-client/src/redaction.rs b/crates/devtools-client/src/redaction.rs index ab7302f..7e560f7 100644 --- a/crates/devtools-client/src/redaction.rs +++ b/crates/devtools-client/src/redaction.rs @@ -1,16 +1,95 @@ #![forbid(unsafe_code)] //! Typed redaction for previews and traces. +use std::borrow::Cow; + use crate::bounds::{PREVIEW_MAX_BYTES, truncate_to_bytes}; +/// NORM-1 normalization class (normative; the single definition shared with +/// `src/redaction.ts`). +/// +/// The class is every code point above U+007F that Unicode classifies as +/// `Default_Ignorable_Code_Point`, as general category `Cf` +/// (Other_Format), or as `White_Space`. Membership is decided by Unicode +/// character properties only; this table is generated from that definition, +/// never hand-curated, and both language test suites execute +/// `tests/fixtures/redaction-normalization-class.txt` to pin the exact set. +/// +/// Rationale: every member renders as nothing at all (a format control or a +/// default-ignorable code point) or as blank (a non-ASCII space separator), so +/// a hostile producer can inject any of them to break a literal credential +/// pattern match without changing what the operator sees on screen. They are +/// therefore removed before secret matching. Membership is 4225 code points in +/// 29 ranges for Unicode 17.0. +/// +/// C0, DEL, and C1 controls are deliberately not in the class: they are +/// escaped for rendering, not silently deleted, so an escape is never +/// swallowed. U+0085 is the one code point in both sets (Cc and White_Space); +/// `normalize_for_matching` removes it for matching and the renderer escapes +/// it, matching `sanitizeTerminalOutput` in `src/redaction.ts`. +const NORM_1_RANGES: &[(char, char)] = &[ + ('\u{85}', '\u{85}'), // U+85 + ('\u{a0}', '\u{a0}'), // U+A0 + ('\u{ad}', '\u{ad}'), // U+AD + ('\u{34f}', '\u{34f}'), // U+34F + ('\u{600}', '\u{605}'), // U+600-U+605 + ('\u{61c}', '\u{61c}'), // U+61C + ('\u{6dd}', '\u{6dd}'), // U+6DD + ('\u{70f}', '\u{70f}'), // U+70F + ('\u{890}', '\u{891}'), // U+890-U+891 + ('\u{8e2}', '\u{8e2}'), // U+8E2 + ('\u{115f}', '\u{1160}'), // U+115F-U+1160 + ('\u{1680}', '\u{1680}'), // U+1680 + ('\u{17b4}', '\u{17b5}'), // U+17B4-U+17B5 + ('\u{180b}', '\u{180f}'), // U+180B-U+180F + ('\u{2000}', '\u{200f}'), // U+2000-U+200F + ('\u{2028}', '\u{202f}'), // U+2028-U+202F + ('\u{205f}', '\u{206f}'), // U+205F-U+206F + ('\u{3000}', '\u{3000}'), // U+3000 + ('\u{3164}', '\u{3164}'), // U+3164 + ('\u{fe00}', '\u{fe0f}'), // U+FE00-U+FE0F + ('\u{feff}', '\u{feff}'), // U+FEFF + ('\u{ffa0}', '\u{ffa0}'), // U+FFA0 + ('\u{fff0}', '\u{fffb}'), // U+FFF0-U+FFFB + ('\u{110bd}', '\u{110bd}'), // U+110BD + ('\u{110cd}', '\u{110cd}'), // U+110CD + ('\u{13430}', '\u{1343f}'), // U+13430-U+1343F + ('\u{1bca0}', '\u{1bca3}'), // U+1BCA0-U+1BCA3 + ('\u{1d173}', '\u{1d17a}'), // U+1D173-U+1D17A + ('\u{e0000}', '\u{e0fff}'), // U+E0000-U+E0FFF +]; + +fn is_unicode_format_separator(character: char) -> bool { + NORM_1_RANGES + .iter() + .any(|(low, high)| character >= *low && character <= *high) +} + +fn normalize_for_matching(value: &str) -> Cow<'_, str> { + if !value + .chars() + .any(|character| character.is_control() || is_unicode_format_separator(character)) + { + return Cow::Borrowed(value); + } + Cow::Owned( + value + .chars() + .filter(|character| !character.is_control() && !is_unicode_format_separator(*character)) + .collect(), + ) +} + pub fn is_sensitive_field(name: &str) -> bool { - let lower = name.to_ascii_lowercase(); + let normalized = normalize_for_matching(name); + let lower = normalized.to_ascii_lowercase(); [ "password", "secret", "token", "api_key", "api-key", + "apikey", "authorization", "cookie", ] @@ -51,18 +130,38 @@ fn contains_phrase(value: &str, needle: &str) -> bool { contains_lower(value, needle) } -/// Scan for `key [=:] secret` assignment phrases (password, secret, -/// api-key, auth/access token) and `bearer ` phrases, in any case. +/// Case-insensitive prefilter for `key[0]`: the scan must reach every ASCII +/// spelling of the first byte, otherwise the `eq_ignore_ascii_case` verification +/// below is unreachable for a capitalized, upper-case, or mixed-case key. +fn starts_key_candidate(bytes: &[u8], key_first: u8) -> Option { + let lowered = key_first.to_ascii_lowercase(); + bytes + .iter() + .position(|byte| byte.to_ascii_lowercase() == lowered) +} + +/// Scan for `key [=:] secret` assignment phrases and bearer token phrases. fn contains_secret_phrase(value: &str) -> bool { - const KEYS: [&str; 6] = [ - "password", "passwd", "secret", "api_key", "api-key", "apikey", + const KEYS: [&str; 12] = [ + "password", + "passwd", + "secret", + "api_key", + "api-key", + "apikey", + "authorization", + "auth", + "token", + "access_token", + "cookie", + "credential", ]; let bytes = value.as_bytes(); for key in KEYS { let key = key.as_bytes(); let mut start = 0; while start + key.len() <= bytes.len() { - let Some(rel) = bytes[start..].iter().position(|b| *b == key[0]) else { + let Some(rel) = starts_key_candidate(&bytes[start..], key[0]) else { break; }; let i = start + rel; @@ -81,7 +180,7 @@ fn contains_secret_phrase(value: &str) -> bool { return true; } } - contains_bearer_token(value) + contains_bearer_token(value) || contains_credential_name(value) } /// Check whether `rest` (text after a matched key) is an assignment: optional @@ -135,11 +234,12 @@ fn contains_key_assignment(value: &str, key: &str) -> bool { false } -/// Match `bearer ` (any case) where the token is a non-space run. +/// Match `bearer ` and normalized joined `bearer` forms. fn contains_bearer_token(value: &str) -> bool { const KEY: &str = "bearer"; + const MIN_JOINED_TOKEN: usize = 8; let vb = value.as_bytes(); - if KEY.len() + 2 > vb.len() { + if KEY.len() >= vb.len() { return false; } for i in 0..=vb.len() - KEY.len() { @@ -149,12 +249,23 @@ fn contains_bearer_token(value: &str) -> bool { let Some(after) = value.get(i + KEY.len()..) else { continue; }; - let mut chars = after.chars(); - match chars.next() { - Some(' ') | Some('\t') => {} - _ => continue, + let after_bytes = after.as_bytes(); + if matches!(after_bytes.first(), Some(b' ' | b'\t')) { + if after_bytes + .iter() + .skip_while(|byte| matches!(**byte, b' ' | b'\t')) + .any(|byte| !byte.is_ascii_whitespace()) + { + return true; + } + continue; } - if chars.any(|c| !c.is_whitespace()) { + if after_bytes + .iter() + .take_while(|byte| is_joined_bearer_char(**byte)) + .count() + >= MIN_JOINED_TOKEN + { return true; } } @@ -165,6 +276,96 @@ fn is_bearer_char(b: u8) -> bool { b.is_ascii_alphanumeric() || matches!(b, b'-' | b'.' | b'_' | b'~' | b'+' | b'/') } +/// Token characters for the joined `bearer` scan. This is the +/// `assignmentOrBearerPattern` character class in `src/redaction.ts`, which +/// also admits `=`; `=` is a base64 pad character, so a joined token shorter +/// than eight characters before its padding is still a token. Kept separate +/// from [`is_bearer_char`] because `is_bearer_char` also delimits JWT parts, +/// where admitting `=` would swallow the padding into a part and lose the +/// shape. +fn is_joined_bearer_char(b: u8) -> bool { + is_bearer_char(b) || b == b'=' +} + +fn is_name_separator(b: u8) -> bool { + matches!(b, b'-' | b'_') +} + +fn is_name_run_char(b: u8) -> bool { + b.is_ascii_alphanumeric() || is_name_separator(b) +} + +/// True when `bytes[from..]` is optional space/tab then `:` or `=`. This is +/// the `(?!\s*[:=])` lookahead of the credential-name rule, and it is +/// deliberately weaker than [`is_assignment_after`]: the name rule only has to +/// know that a value delimiter follows, not that a value is present. +fn followed_by_assignment_delimiter(bytes: &[u8], from: usize) -> bool { + let mut index = from; + while matches!(bytes.get(index), Some(b' ' | b'\t')) { + index += 1; + } + matches!(bytes.get(index), Some(b':' | b'=')) +} + +/// A bare credential-bearing configuration name (`GITHUB_TOKEN`, `API_KEY`, +/// `MY_SECRET_VALUE`) is itself sensitive even with no value beside it. +/// +/// Mirrors `credentialNamePattern` in `src/redaction.ts`, and is deliberately +/// case-SENSITIVE on the credential name: only the SCREAMING_SNAKE spelling is +/// a finding, so "the password is required to log in" and "Tokens expire after +/// one hour" stay intact. The case-insensitive rule that *is* wanted lives in +/// [`contains_secret_phrase`], which requires an assignment delimiter. +/// +/// The match is a segment-aligned credential name inside a maximal +/// `[A-Za-z0-9_-]` run, with the name ending a segment (or the run). The +/// negative lookahead is only consulted when the name ends the run, because any +/// earlier window end sits inside the run and is therefore followed by an +/// alphanumeric or a separator, which never satisfies `\s*[:=]`. A run whose +/// internal separator structure is irregular still reports here and not in +/// TypeScript, so this rule is a superset and never weaker. +fn contains_credential_name(value: &str) -> bool { + const NAMES: [&[u8]; 5] = [b"SECRET", b"TOKEN", b"PASSWORD", b"CREDENTIAL", b"API_KEY"]; + let bytes = value.as_bytes(); + let mut run_start = 0; + while run_start < bytes.len() { + if !is_name_run_char(bytes[run_start]) { + run_start += 1; + continue; + } + let mut run_end = run_start; + while run_end < bytes.len() && is_name_run_char(bytes[run_end]) { + run_end += 1; + } + let run = &bytes[run_start..run_end]; + 'names: for name in NAMES { + if run.len() < name.len() { + continue; + } + for at in 0..=run.len() - name.len() { + if run[at..at + name.len()] != *name { + continue; + } + if at != 0 && !is_name_separator(run[at - 1]) { + continue; + } + let after = at + name.len(); + if after < run.len() { + if is_name_separator(run[after]) { + return true; + } + continue; + } + if !followed_by_assignment_delimiter(bytes, run_end) { + return true; + } + continue 'names; + } + } + run_start = run_end; + } + false +} + fn is_token_char(b: u8) -> bool { b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'+' | b'/' | b'=' | b'.' | b'~') } @@ -192,7 +393,7 @@ fn contains_secret_token(value: &str) -> bool { let prefix = prefix.as_bytes(); let mut start = 0; while start + prefix.len() <= bytes.len() { - let Some(rel) = bytes[start..].iter().position(|b| *b == prefix[0]) else { + let Some(rel) = starts_key_candidate(&bytes[start..], prefix[0]) else { break; }; let i = start + rel; @@ -394,7 +595,8 @@ fn contains_secret(value: &str) -> bool { /// Value-side secret scan: embedded credential shapes and high-entropy /// tokens, regardless of field name. pub fn looks_secret(value: &str) -> bool { - contains_secret(value) || looks_like_high_entropy_secret(value) + let normalized = normalize_for_matching(value); + contains_secret(&normalized) || looks_like_high_entropy_secret(&normalized) } pub struct RedactionMarker { @@ -438,6 +640,219 @@ pub fn preview_equals_export(preview: &str, export: &str) -> bool { mod tests { use super::*; + const REDACTION_SEPARATOR_CORPUS: &str = + include_str!("../../../tests/fixtures/redaction-separator-corpus.txt"); + const REDACTION_NORMALIZATION_CLASS: &str = + include_str!("../../../tests/fixtures/redaction-normalization-class.txt"); + + /// Every code point the NORM-1 class must contain, and the near-miss + /// code points it must not contain. The fixture is shared with the + /// TypeScript suite, so class membership cannot drift between languages + /// without failing a gate on both sides. + #[test] + fn norm_1_normalization_class_matches_shared_pin() { + let mut members = 0usize; + let mut non_members = 0usize; + for line in REDACTION_NORMALIZATION_CLASS.lines() { + if line.is_empty() || line.starts_with('#') { + continue; + } + let mut columns = line.split('\t'); + let kind = columns.next().expect("class row kind"); + let code_point = columns.next().expect("class row code point"); + assert!(columns.next().is_none(), "unexpected class row column"); + let parsed = u32::from_str_radix(code_point, 16).expect("valid hex"); + let character = char::from_u32(parsed) + .unwrap_or_else(|| panic!("class row {code_point} is not a scalar value")); + let actual = is_unicode_format_separator(character); + match kind { + "member" => { + assert!(actual, "class row U+{code_point} must be normalized"); + members += 1; + } + "nonmember" => { + assert!(!actual, "class row U+{code_point} must be preserved"); + non_members += 1; + } + other => panic!("unknown class row kind {other}"), + } + } + assert_eq!(members, 4225, "NORM-1 membership pin is complete"); + assert!(non_members >= 256, "NORM-1 boundary pin is present"); + } + + /// The class is a superset of every spelling either language used before, + /// and the table and the pin agree on every code point in the fixture. + #[test] + fn norm_1_table_covers_all_class_members() { + let mut counted = 0usize; + for line in REDACTION_NORMALIZATION_CLASS.lines() { + if line.is_empty() || line.starts_with('#') { + continue; + } + let mut columns = line.split('\t'); + if columns.next() != Some("member") { + continue; + } + let code_point = columns.next().expect("class row code point"); + let parsed = u32::from_str_radix(code_point, 16).expect("valid hex"); + let Some(character) = char::from_u32(parsed) else { + continue; + }; + assert!( + NORM_1_RANGES + .iter() + .any(|(low, high)| character >= *low && character <= *high), + "U+{code_point} is pinned as a member but no table range covers it" + ); + counted += 1; + } + assert_eq!(counted, 4225); + assert_eq!(NORM_1_RANGES.len(), 29, "NORM-1 is 29 ranges"); + } + + fn decode_hex_corpus_value(hex: &str) -> Vec { + assert_eq!(hex.len() % 2, 0, "invalid hex corpus value"); + hex.as_bytes() + .chunks_exact(2) + .map(|pair| { + let text = std::str::from_utf8(pair).expect("corpus hex is ASCII"); + u8::from_str_radix(text, 16).expect("corpus hex is valid") + }) + .collect() + } + + #[test] + fn px_0514_shared_differential_corpus() { + let mut cases = 0; + for line in REDACTION_SEPARATOR_CORPUS.lines() { + if line.is_empty() || line.starts_with('#') { + continue; + } + let mut columns = line.split('\t'); + let id = columns.next().expect("corpus id"); + let hex = columns.next().expect("corpus hex"); + let expected = columns.next().expect("corpus expectation"); + assert!(columns.next().is_none(), "unexpected corpus column"); + let input = String::from_utf8(decode_hex_corpus_value(hex)) + .expect("corpus value is valid UTF-8"); + let actual = redact_value(input.clone(), "notes"); + let wanted = if expected == "true" { + "[REDACTED]".to_string() + } else { + input + }; + assert_eq!(actual, wanted, "corpus case {id}"); + cases += 1; + } + // Exact count, not a floor: a silently dropped fixture row must fail + // here as loudly as a wrong expectation. The TypeScript suite asserts + // the same total, so a fixture that only one language reads fails both. + assert_eq!(cases, 2298, "shared corpus must be fully executed"); + } + + /// P1 regression: the candidate key-position prefilter must be ASCII + /// case-insensitive, otherwise the `eq_ignore_ascii_case` verification is + /// unreachable for any key whose first byte is not already lowercase. + #[test] + fn p1_key_position_prefilter_is_case_insensitive() { + const MARKER: &str = "SYNTHETIC_OPAQUE_123456"; + const KEYS: [&str; 17] = [ + "password", + "passwd", + "secret", + "api_key", + "api-key", + "apikey", + "authorization", + "proxy-authorization", + "proxy_authorization", + "auth", + "token", + "access_token", + "access-token", + "auth_token", + "auth-token", + "cookie", + "credential", + ]; + let spellings = |key: &str| -> Vec { + let mut forms = vec![key.to_string(), key.to_uppercase()]; + let mut mixed = String::new(); + for (index, character) in key.chars().enumerate() { + if index % 2 == 0 { + mixed.extend(character.to_uppercase()); + } else { + mixed.push(character); + } + } + forms.push(mixed); + let mut title = String::new(); + let mut capitalize = true; + for character in key.chars() { + if character == '_' || character == '-' { + title.push(character); + capitalize = true; + continue; + } + if capitalize { + title.extend(character.to_uppercase()); + capitalize = false; + } else { + title.push(character); + } + } + forms.push(title); + forms + }; + for key in KEYS { + for spelling in spellings(key) { + for separator in [": ", "= ", ":", "=", " : ", " = ", "\t= "] { + let input = format!("{spelling}{separator}{MARKER}"); + assert_eq!( + redact_value(input.clone(), "notes"), + "[REDACTED]", + "assignment phrase must redact: {input:?}" + ); + } + } + } + } + + /// The provider-token prefilter has the same defect class and the same + /// fix: a lower-case spelling of a mixed-case prefix must still be found. + #[test] + fn p1_token_prefix_prefilter_is_case_insensitive() { + for (spelling, marker) in [ + ("AIza", "aizasyndheticopaque123456"), + ("aiza", "aizasyndheticopaque123456"), + ("AKIA", "akiaIOSFODNN7EXAMPLE"), + ("akia", "akiaIOSFODNN7EXAMPLE"), + ] { + let input = format!("{spelling}{marker}"); + assert_eq!( + redact_value(input.clone(), "notes"), + "[REDACTED]", + "provider token must redact: {input:?}" + ); + } + } + + /// Sentence-style prose that merely mentions a key name must survive. + #[test] + fn p1_case_insensitive_prefilter_does_not_widen_prose() { + for text in [ + "Passwords are required to log in", + "The Authorization header is optional", + "Tokens expire after one hour", + "release 1.2.3", + "thequickbrownfoxjumpsoverthelazydogagainx", + "src/components/VeryLongComponentName/index.ts", + ] { + assert_eq!(redact_value(text.to_string(), "notes"), text); + } + } + #[test] fn sensitive_detection() { assert!(is_sensitive_field("password")); diff --git a/src/campaign.ts b/src/campaign.ts index 28f2d4a..6606b17 100644 --- a/src/campaign.ts +++ b/src/campaign.ts @@ -24,6 +24,8 @@ */ import { DIR_MODE } from "./auth.js"; +import { truncateToBytes } from "./bounds.js"; +import { redactSensitiveText, sanitizeTerminalOutput } from "./redaction.js"; function isAbsoluteSocketPath(socketPath: string): boolean { const platform = (globalThis as { process?: { platform?: string } }).process @@ -35,11 +37,9 @@ function isAbsoluteSocketPath(socketPath: string): boolean { } function campaignFailureMessage(error: unknown): string { - try { - return error instanceof Error ? error.message : String(error); - } catch { - return "unknown campaign failure"; - } + return error instanceof CampaignError + ? safeReportText(`campaign failure (${error.code}): ${error.message}`) + : "campaign operation failed"; } // --------------------------------------------------------------------------- @@ -73,6 +73,42 @@ export const EXIT_TIMEOUT = 124 as const; export const DEFAULT_TIMEOUT_MS = 10_000 as const; /** Default bound on captured live output (guards Debug-dump blowups). */ export const MAX_CAMPAIGN_OUTPUT_BYTES = 4 * 1024 * 1024; +export const MAX_CAMPAIGN_COMMAND_BYTES = 512 as const; +export const MAX_CAMPAIGN_ERROR_CLASS_BYTES = 128 as const; +export const MAX_CAMPAIGN_ERROR_MESSAGE_BYTES = 1024 as const; +export const MAX_CAMPAIGN_STRING_BYTES = 256 * 1024; +export const MAX_CAMPAIGN_ARRAY_ITEMS = 256 as const; +export const MAX_CAMPAIGN_OBJECT_KEYS = 128 as const; +export const MAX_CAMPAIGN_JSON_DEPTH = 16 as const; +export const MAX_CAMPAIGN_JSON_NODES = 4096 as const; +export const MAX_CAMPAIGN_WORKSPACES = 64 as const; +export const MAX_CAMPAIGN_MATRIX_ROWS = 64 as const; +export const MAX_CAMPAIGN_REPORT_RESULTS = 128 as const; +export const MAX_CAMPAIGN_REPORT_EVIDENCE_ITEMS = 16 as const; +export const MAX_CAMPAIGN_REPORT_TEXT_BYTES = 1024 as const; +export const MAX_CAMPAIGN_ARGS = 64 as const; +export const MAX_CAMPAIGN_ARG_BYTES = 4096 as const; +export const MAX_CAMPAIGN_IDENTIFIER_BYTES = 128 as const; +export const MAX_CAMPAIGN_CHILD_ENV_VALUE_BYTES = 4096 as const; + +export const CAMPAIGN_CHILD_ENV_ALLOWLIST = [ + "PATH", + "Path", + "HOME", + "XDG_RUNTIME_DIR", + "XDG_CONFIG_HOME", + "TMPDIR", + "TMP", + "TEMP", + "LANG", + "LC_ALL", + "LC_CTYPE", + "SystemRoot", + "SYSTEMROOT", + "WINDIR", + "PATHEXT", + "COMSPEC", +] as const; /** Stable exit-code table, keyed by normalized failure class/code. */ export function expectedExitForError(errorClass: string, code: string): number { @@ -147,7 +183,11 @@ export type CtlEnvelope = CtlSuccessEnvelope | CtlFailureEnvelope; export class CampaignError extends Error { constructor( public readonly code: - "MalformedEnvelope" | "MissingField" | "InvalidJson" | "EmptyOutput", + | "MalformedEnvelope" + | "MissingField" + | "InvalidJson" + | "EmptyOutput" + | "OutputTooLarge", message: string, ) { super(message); @@ -159,6 +199,108 @@ function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } +function utf8Bytes(value: string): number { + return new TextEncoder().encode(value).length; +} + +function assertBoundedString( + field: string, + value: unknown, + maxBytes: number, +): asserts value is string { + if (typeof value !== "string" || value.length === 0) { + throw new CampaignError( + "MalformedEnvelope", + `${field} must be a non-empty string`, + ); + } + if (utf8Bytes(value) > maxBytes) { + throw new CampaignError( + "OutputTooLarge", + `${field} exceeds ${maxBytes} bytes`, + ); + } +} + +function hasControlCharacters(value: string): boolean { + return Array.from(value).some((character) => { + const codePoint = character.codePointAt(0) ?? 0; + return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f); + }); +} + +function validateBoundedJsonValue(value: unknown): string[] { + const problems: string[] = []; + let nodes = 0; + const visit = (entry: unknown, depth: number, path: string): void => { + nodes += 1; + if (nodes > MAX_CAMPAIGN_JSON_NODES) { + problems.push(`result exceeds ${MAX_CAMPAIGN_JSON_NODES} values`); + return; + } + if (depth > MAX_CAMPAIGN_JSON_DEPTH) { + problems.push(`result exceeds depth ${MAX_CAMPAIGN_JSON_DEPTH}`); + return; + } + if (typeof entry === "string") { + if (utf8Bytes(entry) > MAX_CAMPAIGN_STRING_BYTES) { + problems.push( + `result string at ${path} exceeds ${MAX_CAMPAIGN_STRING_BYTES} bytes`, + ); + } + return; + } + if (Array.isArray(entry)) { + if (entry.length > MAX_CAMPAIGN_ARRAY_ITEMS) { + problems.push( + `result array at ${path} exceeds ${MAX_CAMPAIGN_ARRAY_ITEMS} items`, + ); + return; + } + for (const [index, item] of entry.entries()) { + visit(item, depth + 1, `${path}[${index}]`); + if (problems.length >= 8) return; + } + return; + } + if (isRecord(entry)) { + const keys = Object.keys(entry); + if (keys.length > MAX_CAMPAIGN_OBJECT_KEYS) { + problems.push( + `result object at ${path} exceeds ${MAX_CAMPAIGN_OBJECT_KEYS} fields`, + ); + return; + } + for (const key of keys) { + if (utf8Bytes(key) > MAX_CAMPAIGN_IDENTIFIER_BYTES) { + problems.push( + `result key at ${path} exceeds ${MAX_CAMPAIGN_IDENTIFIER_BYTES} bytes`, + ); + continue; + } + visit(entry[key], depth + 1, `${path}.${key}`); + if (problems.length >= 8) return; + } + return; + } + if (typeof entry === "number" && !Number.isFinite(entry)) { + problems.push(`result number at ${path} must be finite`); + } + }; + visit(value, 0, "result"); + return problems; +} + +function unexpectedEnvelopeFields( + value: Record, + allowed: readonly string[], +): string[] { + const allowSet = new Set(allowed); + return Object.keys(value) + .filter((key) => !allowSet.has(key)) + .map((key) => `unexpected field ${JSON.stringify(safeReportText(key))}`); +} + /** * Validate the shape of a decoded envelope. Returns a list of human-readable * problems (empty when the envelope is well formed). Never throws. @@ -169,37 +311,166 @@ export function validateEnvelopeShape(value: unknown): string[] { if (value["v"] !== CTL_ENVELOPE_VERSION) { problems.push(`v must be ${CTL_ENVELOPE_VERSION}`); } - if (typeof value["command"] !== "string" || value["command"].length === 0) { + const command = value["command"]; + if (typeof command !== "string" || command.length === 0) { problems.push("command must be a non-empty string"); + } else { + if (utf8Bytes(command) > MAX_CAMPAIGN_COMMAND_BYTES) { + problems.push(`command exceeds ${MAX_CAMPAIGN_COMMAND_BYTES} bytes`); + } + if (hasControlCharacters(command)) { + problems.push("command must not contain control characters"); + } } if (typeof value["ok"] !== "boolean") { problems.push("ok must be boolean"); } else if (value["ok"] === true) { - if (!("result" in value)) problems.push("ok:true requires a result field"); + if (!Object.hasOwn(value, "result")) { + problems.push("result/error branches are exclusive"); + } + if (Object.hasOwn(value, "error")) { + problems.push("result/error branches are exclusive"); + } + problems.push( + ...unexpectedEnvelopeFields(value, ["v", "command", "ok", "result"]), + ); + if (Object.hasOwn(value, "result")) { + problems.push(...validateBoundedJsonValue(value["result"])); + } } else { - const err = value["error"]; - if (!isRecord(err)) { + const error = value["error"]; + if (Object.hasOwn(value, "result") || !Object.hasOwn(value, "error")) { + problems.push("result/error branches are exclusive"); + } + problems.push( + ...unexpectedEnvelopeFields(value, ["v", "command", "ok", "error"]), + ); + if (!isRecord(error)) { problems.push("ok:false requires an error object"); } else { - for (const key of ["class", "code", "message"] as const) { - if (typeof err[key] !== "string" || err[key].length === 0) { + problems.push( + ...unexpectedEnvelopeFields(error, ["class", "code", "message"]), + ); + const fields = [ + ["class", MAX_CAMPAIGN_ERROR_CLASS_BYTES], + ["code", MAX_CAMPAIGN_ERROR_CLASS_BYTES], + ["message", MAX_CAMPAIGN_ERROR_MESSAGE_BYTES], + ] as const; + for (const [key, limit] of fields) { + const entry = error[key]; + if (typeof entry !== "string" || entry.length === 0) { problems.push(`error.${key} must be a non-empty string`); + } else { + if (utf8Bytes(entry) > limit) { + problems.push(`error.${key} exceeds ${limit} bytes`); + } + if (hasControlCharacters(entry)) { + problems.push(`error.${key} must not contain control characters`); + } + if (redactSensitiveText(entry) !== entry) { + problems.push(`error.${key} contains sensitive material`); + } } } } } - return problems; + return [...new Set(problems)].slice(0, 8).map(safeReportText); } -/** Parse a v1 `ctl` envelope from CLI stdout; throws {@link CampaignError}. */ -export function parseCtlEnvelope(stdout: string): CtlEnvelope { - const trimmed = stdout.trim(); - if (trimmed.length === 0) { +/** + * Reject a ctl stdout envelope that repeats an object key. `JSON.parse` keeps + * the last occurrence, so a duplicate key lets a hostile target show one value + * to the operator and hand a different one to every later consumer. + * Single-line JSONL only: `parseCtlEnvelopeShape` rejects embedded newlines + * before this runs. + */ +function assertCtlEnvelopeUniqueKeys(raw: string): void { + const stack: Array< + { kind: "object"; keys: Set } | { kind: "array" } + > = []; + for (let index = 0; index < raw.length; index += 1) { + const character = raw[index]; + if (character === "{") { + stack.push({ kind: "object", keys: new Set() }); + continue; + } + if (character === "[") { + stack.push({ kind: "array" }); + continue; + } + if (character === "}" || character === "]") { + const expected = character === "}" ? "object" : "array"; + const current = stack.pop(); + if (current?.kind !== expected) { + throw new SyntaxError("JSON contains mismatched structure"); + } + continue; + } + if (character !== '"') continue; + let end = index + 1; + let escaped = false; + for (; end < raw.length; end += 1) { + const code = raw.charCodeAt(end); + if (escaped) { + escaped = false; + continue; + } + if (raw[end] === "\\") { + escaped = true; + continue; + } + if (raw[end] === '"') break; + if (code < 0x20) { + throw new SyntaxError("JSON string contains a control character"); + } + } + if (end >= raw.length) { + throw new SyntaxError("JSON contains an unterminated string"); + } + const current = stack.at(-1); + if (current?.kind === "object") { + let next = end + 1; + while (next < raw.length && /\s/u.test(raw[next] ?? "")) next += 1; + if (raw[next] === ":") { + const parsedKey: unknown = JSON.parse(raw.slice(index, end + 1)); + if (typeof parsedKey !== "string") { + throw new SyntaxError("JSON object key is not a string"); + } + if (current.keys.has(parsedKey)) { + throw new SyntaxError("JSON contains a duplicate object key"); + } + current.keys.add(parsedKey); + } + } + index = end; + } + if (stack.length > 0) { + throw new SyntaxError("JSON contains unclosed structure"); + } +} + +function parseCtlEnvelopeShape(stdout: string): CtlEnvelope { + if (utf8Bytes(stdout) > MAX_CAMPAIGN_OUTPUT_BYTES) { + throw new CampaignError( + "OutputTooLarge", + `ctl stdout exceeds ${MAX_CAMPAIGN_OUTPUT_BYTES} bytes`, + ); + } + let line = stdout; + if (line.endsWith("\r\n")) line = line.slice(0, -2); + else if (line.endsWith("\n")) line = line.slice(0, -1); + if (line.trim().length === 0) { throw new CampaignError("EmptyOutput", "ctl produced no stdout envelope"); } - const line = trimmed.split("\n")[0] ?? ""; + if (line.includes("\n") || line.includes("\r")) { + throw new CampaignError( + "MalformedEnvelope", + "ctl stdout must contain exactly one JSONL record", + ); + } let parsed: unknown; try { + assertCtlEnvelopeUniqueKeys(line); parsed = JSON.parse(line); } catch { throw new CampaignError("InvalidJson", "ctl stdout is not valid JSON"); @@ -208,12 +479,27 @@ export function parseCtlEnvelope(stdout: string): CtlEnvelope { if (problems.length > 0) { throw new CampaignError( "MalformedEnvelope", - `invalid ctl envelope: ${problems.join("; ")}`, + safeReportText(`invalid ctl envelope: ${problems.join("; ")}`), ); } return parsed as CtlEnvelope; } +/** Parse a v1 `ctl` envelope from CLI stdout; throws {@link CampaignError}. */ +export function parseCtlEnvelope(stdout: string): CtlEnvelope { + const envelope = parseCtlEnvelopeShape(stdout); + if (envelope.ok) { + if (!envelope.command.startsWith("core.")) { + throw new CampaignError( + "MalformedEnvelope", + "ctl command does not name a known registry verb", + ); + } + assertCtlResultProjection(envelope.command.slice(5), envelope); + } + return envelope; +} + /** Result of one `ctl` invocation (bounded, observation-only). */ export type CtlResult = { argv: readonly string[]; @@ -223,6 +509,40 @@ export type CtlResult = { timedOut: boolean; }; +function assertBoundedCtlResult(result: CtlResult): void { + if ( + !Number.isSafeInteger(result.exitCode) || + typeof result.timedOut !== "boolean" || + !Array.isArray(result.argv) || + result.argv.length > MAX_CAMPAIGN_ARGS + ) { + throw new CampaignError( + "MalformedEnvelope", + "ctl result metadata is invalid", + ); + } + for (const argument of result.argv) { + assertBoundedProcessToken(argument, "ctl result argv"); + } + for (const [field, value] of [ + ["stdout", result.stdout], + ["stderr", result.stderr], + ] as const) { + if (typeof value !== "string") { + throw new CampaignError( + "MalformedEnvelope", + `ctl ${field} must be a string`, + ); + } + if (utf8Bytes(value) > MAX_CAMPAIGN_OUTPUT_BYTES) { + throw new CampaignError( + "OutputTooLarge", + `ctl ${field} exceeds ${MAX_CAMPAIGN_OUTPUT_BYTES} bytes`, + ); + } + } +} + /** One `ctl` invocation to dispatch. */ export type CtlInvocation = { /** Stable verb label, e.g. `workspace.list`. */ @@ -328,24 +648,48 @@ export type SpawnSyncFn = ( args: readonly string[], options: { timeoutMs: number; - /** Environment delta merged over the host environment by the default spawn. */ + /** Allowlisted environment overlay applied to the minimal child environment. */ env: Record; cwd?: string; }, ) => CtlResult; -/** - * `BITTY_CTL_ELEVATE` scope list announced for elevated invocations. - * - * The variable is a server-side pre-grant allowlist of comma-separated scope - * names (for example `terminal.manage,config.modify`); the server intersects - * them with its own allowlist and unknown names grant nothing. A bare `1` is - * not a scope and therefore grants nothing, which is why an elevated probe - * must announce the scopes it needs. This is observation-only wiring: the - * server remains the authority and still fails closed on a missing grant. - */ +/** Default server-side scope allowlist; each verb announces only its mapped scope. */ export const DEFAULT_ELEVATION_SCOPES = "terminal.manage,config.modify"; +const ELEVATION_SCOPE_BY_VERB: Readonly> = { + "terminal.spawn": "terminal.manage", + "terminal.close": "terminal.manage", + "workspace.close": "terminal.manage", + "config.reload": "config.modify", +}; + +const SUPPORTED_ELEVATION_SCOPES = new Set([ + "terminal.manage", + "config.modify", +]); + +function parseElevationScopes(raw: string): ReadonlySet { + const entries = raw.split(","); + if (entries.length === 0 || entries.length > 8) { + throw new CampaignError( + "MalformedEnvelope", + "elevation scope list is empty or too large", + ); + } + const scopes = new Set(); + for (const entry of entries) { + if (!SUPPORTED_ELEVATION_SCOPES.has(entry)) { + throw new CampaignError( + "MalformedEnvelope", + "elevation scope list contains an unsupported scope", + ); + } + scopes.add(entry); + } + return scopes; +} + export type ProcessDispatcherConfig = { /** Program to execute; defaults to `bitty`. */ program?: string; @@ -355,12 +699,9 @@ export type ProcessDispatcherConfig = { socketPath?: string; /** Command timeout in milliseconds. */ timeoutMs?: number; - /** Extra environment (e.g. `XDG_RUNTIME_DIR`). */ + /** Allowlisted environment overrides (e.g. `XDG_RUNTIME_DIR`). */ env?: Record; - /** - * Comma-separated `BITTY_CTL_ELEVATE` scope list announced for elevated - * invocations. Defaults to {@link DEFAULT_ELEVATION_SCOPES}. - */ + /** Comma-separated upper bound for per-verb `BITTY_CTL_ELEVATE` scopes. */ elevationScopes?: string; /** Working directory. */ cwd?: string; @@ -368,8 +709,8 @@ export type ProcessDispatcherConfig = { type BunSpawnResult = { exitCode: number | null; - stdout?: { toString(): string } | null; - stderr?: { toString(): string } | null; + stdout?: { byteLength?: number; toString(): string } | null; + stderr?: { byteLength?: number; toString(): string } | null; signalCode?: string | null; success?: boolean; }; @@ -381,6 +722,7 @@ type BunSpawnSync = (options: { env?: Record; cwd?: string; timeout?: number; + maxBuffer?: number; }) => BunSpawnResult; /** Resolve the runtime `Bun.spawnSync` without taking a compile-time node dep. */ @@ -397,12 +739,78 @@ function resolveHostEnv(): Record { return bun?.env ?? {}; } +function boundedEnvironmentValue(key: string, value: string): string { + if ( + utf8Bytes(value) > MAX_CAMPAIGN_CHILD_ENV_VALUE_BYTES || + hasControlCharacters(value) + ) { + throw new CampaignError( + "MalformedEnvelope", + `child environment value for ${key} is invalid`, + ); + } + return value; +} + +export function buildCampaignChildEnvironment( + hostEnv: Readonly>, + requestedEnv: Readonly>, +): Record { + const env: Record = {}; + for (const key of CAMPAIGN_CHILD_ENV_ALLOWLIST) { + const requested = Object.hasOwn(requestedEnv, key); + const value = requested ? requestedEnv[key] : hostEnv[key]; + if (value !== undefined) env[key] = boundedEnvironmentValue(key, value); + } + if ( + Object.hasOwn(requestedEnv, "BITTY_CTL_ELEVATE") && + requestedEnv["BITTY_CTL_ELEVATE"] !== undefined + ) { + const elevation = requestedEnv["BITTY_CTL_ELEVATE"]; + if (elevation !== "terminal.manage" && elevation !== "config.modify") { + throw new CampaignError( + "MalformedEnvelope", + "child elevation must name exactly one supported scope", + ); + } + env["BITTY_CTL_ELEVATE"] = boundedEnvironmentValue( + "BITTY_CTL_ELEVATE", + elevation, + ); + } + return env; +} + +function boundedSpawnOutput( + output: { byteLength?: number; toString(): string } | null | undefined, + field: string, +): string { + if (output == null) return ""; + if ( + output.byteLength !== undefined && + output.byteLength > MAX_CAMPAIGN_OUTPUT_BYTES + ) { + throw new CampaignError( + "OutputTooLarge", + `ctl ${field} exceeds ${MAX_CAMPAIGN_OUTPUT_BYTES} bytes`, + ); + } + const value = output.toString(); + if (utf8Bytes(value) > MAX_CAMPAIGN_OUTPUT_BYTES) { + throw new CampaignError( + "OutputTooLarge", + `ctl ${field} exceeds ${MAX_CAMPAIGN_OUTPUT_BYTES} bytes`, + ); + } + return value; +} + /** * Default live spawn over the runtime's `Bun.spawnSync`, with a hard timeout * and bounded capture. No node builtin types are required, so the harness * type-checks under the repository's committed dependency pins. */ -export function defaultSpawnSync( +function defaultSpawnSync( program: string, args: readonly string[], options: { @@ -422,22 +830,47 @@ export function defaultSpawnSync( cmd: [program, ...args], stdout: "pipe", stderr: "pipe", - env: { ...resolveHostEnv(), ...options.env }, + env: buildCampaignChildEnvironment(resolveHostEnv(), options.env), cwd: options.cwd, timeout: options.timeoutMs, + maxBuffer: MAX_CAMPAIGN_OUTPUT_BYTES, }); const timedOut = res.exitCode === null && res.signalCode === "SIGTERM"; - const stdout = res.stdout?.toString() ?? ""; - const stderr = res.stderr?.toString() ?? ""; return { argv: [program, ...args], exitCode: timedOut ? EXIT_TIMEOUT : (res.exitCode ?? EXIT_GENERIC), - stdout: stdout.slice(0, MAX_CAMPAIGN_OUTPUT_BYTES), - stderr: stderr.slice(0, MAX_CAMPAIGN_OUTPUT_BYTES), + stdout: boundedSpawnOutput(res.stdout, "stdout"), + stderr: boundedSpawnOutput(res.stderr, "stderr"), timedOut, }; } +function assertBoundedProcessToken(value: string, field: string): void { + if ( + value.length === 0 || + utf8Bytes(value) > MAX_CAMPAIGN_ARG_BYTES || + hasControlCharacters(value) + ) { + throw new CampaignError( + "MalformedEnvelope", + `${field} is empty, oversized, or contains control characters`, + ); + } +} + +function assertBoundedInvocation(invocation: CtlInvocation): void { + assertBoundedProcessToken(invocation.verb, "ctl verb"); + if (invocation.args.length > MAX_CAMPAIGN_ARGS) { + throw new CampaignError( + "MalformedEnvelope", + `ctl argv exceeds ${MAX_CAMPAIGN_ARGS} arguments`, + ); + } + for (const argument of invocation.args) { + assertBoundedProcessToken(argument, "ctl argument"); + } +} + /** * Live dispatcher that executes the real `bitty ctl` client. Construct it with * an explicit socket and timeout; call it only from an opt-in live entry point. @@ -447,8 +880,8 @@ export class ProcessCtlDispatcher implements CtlDispatcher { private readonly baseArgs: readonly string[]; private readonly socketPath: string | undefined; private readonly timeoutMs: number; - private readonly env: Record; - private readonly elevationScopes: string; + private readonly env: Record; + private readonly elevationScopes: ReadonlySet; private readonly cwd: string | undefined; private readonly spawn: SpawnSyncFn; @@ -457,12 +890,39 @@ export class ProcessCtlDispatcher implements CtlDispatcher { spawn: SpawnSyncFn = defaultSpawnSync, ) { this.program = config.program ?? "bitty"; - this.baseArgs = config.baseArgs ?? ["ctl"]; + this.baseArgs = [...(config.baseArgs ?? ["ctl"])]; this.socketPath = config.socketPath; this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS; - this.env = config.env ?? {}; - this.elevationScopes = config.elevationScopes ?? DEFAULT_ELEVATION_SCOPES; + this.env = buildCampaignChildEnvironment( + {}, + { ...(config.env ?? {}), BITTY_CTL_ELEVATE: undefined }, + ); + this.elevationScopes = parseElevationScopes( + config.elevationScopes ?? DEFAULT_ELEVATION_SCOPES, + ); this.cwd = config.cwd; + assertBoundedProcessToken(this.program, "ctl program"); + if (this.baseArgs.length > MAX_CAMPAIGN_ARGS) { + throw new CampaignError( + "MalformedEnvelope", + `ctl base argv exceeds ${MAX_CAMPAIGN_ARGS} arguments`, + ); + } + for (const argument of this.baseArgs) { + assertBoundedProcessToken(argument, "ctl base argument"); + } + if (this.socketPath !== undefined) { + assertBoundedProcessToken(this.socketPath, "ctl socket path"); + } + if (this.cwd !== undefined) { + assertBoundedProcessToken(this.cwd, "ctl working directory"); + } + if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) { + throw new CampaignError( + "MalformedEnvelope", + "ctl timeout must be a positive safe integer", + ); + } this.spawn = spawn; } @@ -474,15 +934,37 @@ export class ProcessCtlDispatcher implements CtlDispatcher { } async dispatch(invocation: CtlInvocation): Promise { + assertBoundedInvocation(invocation); const args = [...this.baseArgs]; if (this.socketPath !== undefined) { args.push("--socket", this.socketPath); } args.push(...invocation.args); + if (args.length > MAX_CAMPAIGN_ARGS) { + throw new CampaignError( + "MalformedEnvelope", + `ctl argv exceeds ${MAX_CAMPAIGN_ARGS} arguments`, + ); + } const env: Record = { ...this.env }; - env["BITTY_CTL_ELEVATE"] = invocation.elevated - ? this.elevationScopes - : undefined; + if (invocation.elevated) { + const required = ELEVATION_SCOPE_BY_VERB[invocation.verb]; + if (required === undefined) { + throw new CampaignError( + "MalformedEnvelope", + "elevated ctl verb has no per-verb scope mapping", + ); + } + if (!this.elevationScopes.has(required)) { + throw new CampaignError( + "MalformedEnvelope", + "elevated ctl verb is outside the configured scope allowlist", + ); + } + env["BITTY_CTL_ELEVATE"] = required; + } else { + env["BITTY_CTL_ELEVATE"] = undefined; + } return this.spawn(this.program, args, { timeoutMs: this.timeoutMs, env, @@ -507,11 +989,13 @@ const OUTCOME_EXIT: Record = { notfound: EXIT_GENERIC, }; -const OUTCOME_CLASS: Partial> = { - denied: "Denied", - conflict: "Conflict", - unavailable: "Unavailable", - notfound: "NotFound", +const OUTCOME_ERROR: Partial< + Record +> = { + denied: { class: "Denied", code: "ScopeDenied" }, + conflict: { class: "Conflict", code: "Conflict" }, + unavailable: { class: "Unavailable", code: "Transport" }, + notfound: { class: "NotFound", code: "NotFound" }, }; export type VerbExpectation = { @@ -551,6 +1035,7 @@ export type KeystrokeProbeTarget = { export const KEYSTROKE_PROBE_PAYLOAD = "echo BITTY_CAMPAIGN_PROBE" as const; const TERMINAL_ID_RE = /^t:\d+$/; +const VIEW_ID_RE = /^v:\d+$/; /** * Validate an explicit keystroke-probe target. Fails closed unless the caller @@ -571,7 +1056,7 @@ export function assertKeystrokeProbeTarget(target: KeystrokeProbeTarget): void { ) { throw new CampaignError( "MissingField", - `invalid keystroke probe terminal id '${target.terminalId}' (want t:)`, + "keystroke probe terminal id is invalid", ); } if (target.terminalId === "t:1") { @@ -775,12 +1260,47 @@ export type ProbeResult = { evidence: readonly string[]; }; +function safeReportText(value: string): string { + const redacted = redactSensitiveText(value); + const sanitized = sanitizeTerminalOutput( + redacted, + MAX_CAMPAIGN_REPORT_TEXT_BYTES, + ); + if ( + new TextEncoder().encode(sanitized).length < + new TextEncoder().encode(redacted).length + ) { + const suffix = "...[truncated]"; + const prefixLimit = Math.max( + 0, + MAX_CAMPAIGN_REPORT_TEXT_BYTES - new TextEncoder().encode(suffix).length, + ); + return `${truncateToBytes(sanitized, prefixLimit)}${suffix}`; + } + return sanitized; +} + +function normalizeProbeResult(result: ProbeResult): ProbeResult { + const status: ProbeStatus = + result.status === "pass" || result.status === "skip" + ? result.status + : "fail"; + return { + name: safeReportText(result.name), + status, + detail: safeReportText(result.detail), + evidence: result.evidence + .slice(0, MAX_CAMPAIGN_REPORT_EVIDENCE_ITEMS) + .map(safeReportText), + }; +} + function pass( name: string, detail: string, evidence: readonly string[] = [], ): ProbeResult { - return { name, status: "pass", detail, evidence }; + return normalizeProbeResult({ name, status: "pass", detail, evidence }); } function fail( @@ -788,7 +1308,7 @@ function fail( detail: string, evidence: readonly string[] = [], ): ProbeResult { - return { name, status: "fail", detail, evidence }; + return normalizeProbeResult({ name, status: "fail", detail, evidence }); } function skip( @@ -796,11 +1316,77 @@ function skip( detail: string, evidence: readonly string[] = [], ): ProbeResult { - return { name, status: "skip", detail, evidence }; + return normalizeProbeResult({ name, status: "skip", detail, evidence }); +} + +function expectedErrorFor( + outcome: ExpectedOutcome, +): { class: string; code: string } | undefined { + return OUTCOME_ERROR[outcome]; +} + +function assertBoundedVerbExpectation( + value: unknown, +): asserts value is VerbExpectation { + if (!isRecord(value)) { + throw new CampaignError( + "MalformedEnvelope", + "campaign matrix row is invalid", + ); + } + const allowed = new Set([ + "verb", + "args", + "outcome", + "elevated", + "note", + "keystroke", + ]); + if ( + Object.keys(value).some((key) => !allowed.has(key)) || + typeof value["verb"] !== "string" || + value["verb"].length === 0 || + utf8Bytes(value["verb"]) > MAX_CAMPAIGN_IDENTIFIER_BYTES || + hasControlCharacters(value["verb"]) || + typeof value["elevated"] !== "boolean" || + !Array.isArray(value["args"]) || + value["args"].length > MAX_CAMPAIGN_ARGS || + !["ok", "denied", "conflict", "unavailable", "notfound", "usage"].includes( + value["outcome"] as string, + ) || + typeof value["note"] !== "string" || + utf8Bytes(value["note"]) > MAX_CAMPAIGN_REPORT_TEXT_BYTES || + hasControlCharacters(value["note"]) || + (value["keystroke"] !== undefined && + typeof value["keystroke"] !== "boolean") + ) { + throw new CampaignError( + "MalformedEnvelope", + "campaign matrix row is invalid", + ); + } + for (const argument of value["args"]) { + if (typeof argument !== "string") { + throw new CampaignError( + "MalformedEnvelope", + "campaign matrix argument is invalid", + ); + } + assertBoundedProcessToken(argument, "campaign matrix argument"); + } } -function expectedClassFor(outcome: ExpectedOutcome): string | undefined { - return OUTCOME_CLASS[outcome]; +function campaignMatrixProblem(matrix: unknown): string | undefined { + if (!Array.isArray(matrix)) return "campaign matrix is invalid"; + if (matrix.length > MAX_CAMPAIGN_MATRIX_ROWS) { + return `campaign matrix exceeds ${MAX_CAMPAIGN_MATRIX_ROWS} rows`; + } + try { + for (const row of matrix) assertBoundedVerbExpectation(row); + return undefined; + } catch (error) { + return campaignFailureMessage(error); + } } /** @@ -819,6 +1405,10 @@ export async function probeEnvelopeConformance( matrix: readonly VerbExpectation[] = CTL_VERB_MATRIX, opts: { keystrokeTarget?: KeystrokeProbeTarget } = {}, ): Promise { + const matrixProblem = campaignMatrixProblem(matrix); + if (matrixProblem !== undefined) { + return [fail(campaignMatrixFailureName(matrix), matrixProblem)]; + } const results: ProbeResult[] = []; const allowKeystrokes = keystrokeProbeOptIn(opts.keystrokeTarget); for (const expectation of matrix) { @@ -828,7 +1418,6 @@ export async function probeEnvelopeConformance( fail( name, "keystroke probe refused: pass an explicit keystrokeTarget with allowLiveKeystrokes:true and a non-default terminal id", - [`verb=${expectation.verb}`], ), ); continue; @@ -840,10 +1429,9 @@ export async function probeEnvelopeConformance( args: expectation.args, elevated: expectation.elevated, }); - } catch (err) { - results.push( - fail(name, `dispatch threw: ${campaignFailureMessage(err)}`), - ); + assertBoundedCtlResult(result); + } catch (error) { + results.push(fail(name, campaignFailureMessage(error))); continue; } const evidence = [`exit=${result.exitCode}`]; @@ -873,10 +1461,26 @@ export async function probeEnvelopeConformance( let envelope: CtlEnvelope; try { envelope = parseCtlEnvelope(result.stdout); - } catch (err) { - results.push(fail(name, campaignFailureMessage(err), evidence)); + } catch (error) { + results.push(fail(name, campaignFailureMessage(error), evidence)); + continue; + } + if ( + envelope.command !== `core.${canonicalProjectionVerb(expectation.verb)}` + ) { + results.push( + fail(name, "envelope command did not match the verb", evidence), + ); continue; } + if (envelope.ok) { + try { + assertCtlResultProjection(expectation.verb, envelope); + } catch (error) { + results.push(fail(name, campaignFailureMessage(error), evidence)); + continue; + } + } evidence.push(`ok=${envelope.ok}`); const expectOk = expectation.outcome === "ok"; if (envelope.ok !== expectOk) { @@ -890,32 +1494,29 @@ export async function probeEnvelopeConformance( continue; } if (!envelope.ok) { - const expectedClass = expectedClassFor(expectation.outcome); + const expectedError = expectedErrorFor(expectation.outcome); if ( - expectedClass !== undefined && - envelope.error.class !== expectedClass + expectedError !== undefined && + (envelope.error.class !== expectedError.class || + envelope.error.code !== expectedError.code) ) { results.push( - fail( - name, - `expected class ${expectedClass}, got ${envelope.error.class}/${envelope.error.code}`, - [ - ...evidence, - `class=${envelope.error.class}`, - `code=${envelope.error.code}`, - ], - ), + fail(name, "error class/code did not match expectation", [ + ...evidence, + `class=${expectedError.class}`, + `code=${expectedError.code}`, + ]), ); continue; } } if (result.exitCode !== expectedExit) { results.push( - fail(name, `expected exit ${expectedExit}, got ${result.exitCode}`, [ - ...evidence, - `class=${envelope.ok ? "-" : envelope.error.class}`, - `code=${envelope.ok ? "-" : envelope.error.code}`, - ]), + fail( + name, + `expected exit ${expectedExit}, got ${result.exitCode}`, + evidence, + ), ); continue; } @@ -935,7 +1536,7 @@ export async function probeEnvelopeConformance( // --------------------------------------------------------------------------- const WORKSPACE_NAME_RE = /^ws(\d+)$/; -const WORKSPACE_ID_RE = /^ws:\d+$/; +const WORKSPACE_ID_RE = /^ws:(\d+)$/; /** * Validate a workspace identifier before it is spliced into spawned `ctl` @@ -950,17 +1551,32 @@ export function assertSafeWorkspaceId(identifier: string): void { if (WORKSPACE_ID_RE.test(identifier) || WORKSPACE_NAME_RE.test(identifier)) { return; } - throw new CampaignError( - "MissingField", - `invalid workspace id '${identifier}' (want ws: or ws)`, - ); + throw new CampaignError("MissingField", "workspace identifier is invalid"); } -/** Candidate verb ids for a listed workspace identifier (`ws4` -> `ws:4`). */ -export function workspaceIdCandidates(identifier: string): string[] { - const candidates = new Set(); - candidates.add(identifier); - const match = WORKSPACE_NAME_RE.exec(identifier); +function canonicalWorkspaceId(identifier: string): string | undefined { + const bare = WORKSPACE_NAME_RE.exec(identifier); + if (bare?.[1] !== undefined) { + return `ws:${bare[1].replace(/^0+(?=\d)/, "")}`; + } + const canonical = WORKSPACE_ID_RE.exec(identifier); + if (canonical?.[1] !== undefined) { + return `ws:${canonical[1].replace(/^0+(?=\d)/, "")}`; + } + return undefined; +} + +function campaignMatrixFailureName(matrix: unknown): string { + return Array.isArray(matrix) && matrix.length > MAX_CAMPAIGN_MATRIX_ROWS + ? "campaign:matrix-limit" + : "campaign:matrix-invalid"; +} + +/** Candidate verb ids for a listed workspace identifier (`ws4` -> `ws:4`). */ +export function workspaceIdCandidates(identifier: string): string[] { + const candidates = new Set(); + candidates.add(identifier); + const match = WORKSPACE_NAME_RE.exec(identifier); if (match?.[1] !== undefined) { candidates.add(`ws:${match[1]}`); } @@ -972,6 +1588,7 @@ export function workspaceNamesFrom(envelope: CtlEnvelope): string[] { if (!envelope.ok) { throw new CampaignError("MissingField", "workspace list returned an error"); } + assertCtlResultProjection("workspace.list", envelope); const result = envelope.result; if (!isRecord(result) || !Array.isArray(result["workspaces"])) { throw new CampaignError( @@ -979,7 +1596,30 @@ export function workspaceNamesFrom(envelope: CtlEnvelope): string[] { "workspace list result.workspaces missing", ); } - return result["workspaces"].filter((v): v is string => typeof v === "string"); + const workspaces = result["workspaces"]; + if (workspaces.length > MAX_CAMPAIGN_WORKSPACES) { + throw new CampaignError( + "OutputTooLarge", + `workspace list exceeds ${MAX_CAMPAIGN_WORKSPACES} items`, + ); + } + const identifiers: string[] = []; + for (const [index, workspace] of workspaces.entries()) { + try { + assertBoundedString( + "workspace identifier", + workspace, + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); + } catch { + throw new CampaignError( + "MalformedEnvelope", + `workspace identifier at index ${index} is invalid`, + ); + } + identifiers.push(workspace); + } + return identifiers; } /** Read `result.created` from a workspace-new envelope. */ @@ -987,25 +1627,500 @@ export function workspaceCreatedFrom(envelope: CtlEnvelope): string { if (!envelope.ok) { throw new CampaignError("MissingField", "workspace new returned an error"); } + assertCtlResultProjection("workspace.new", envelope); const result = envelope.result; - if (!isRecord(result) || typeof result["created"] !== "string") { + if (!isRecord(result)) { throw new CampaignError( "MissingField", "workspace new result.created missing", ); } + assertBoundedString( + "workspace created identifier", + result["created"], + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); return result["created"]; } -async function dispatchEnvelope( +function projectionObjectProblems( + value: unknown, + keys: readonly string[], +): string[] { + if (!isRecord(value)) return ["result must be an object"]; + const allowed = new Set(keys); + const problems: string[] = []; + if (Object.keys(value).some((key) => !allowed.has(key))) { + problems.push("result has unexpected fields"); + } + if (keys.some((key) => !Object.hasOwn(value, key))) { + problems.push("result is missing required fields"); + } + return problems; +} + +function projectionStringProblem( + value: unknown, + field: string, + maxBytes = MAX_CAMPAIGN_STRING_BYTES, + allowEmpty = false, +): string[] { + if ( + typeof value !== "string" || + (!allowEmpty && value.length === 0) || + utf8Bytes(value) > maxBytes + ) { + return [`result.${field} must be a bounded string`]; + } + return []; +} + +function projectionArrayProblem(value: unknown, field: string): string[] { + if (!Array.isArray(value) || value.length > MAX_CAMPAIGN_ARRAY_ITEMS) { + return [`result.${field} must be a bounded array`]; + } + return []; +} + +function projectionRecordProblem( + value: unknown, + keys: readonly string[], +): string[] { + return projectionObjectProblems(value, keys); +} + +function canonicalProjectionVerb(verb: string): string { + if (verb === "view.list.no-instance") return "view.list"; + if ( + verb === "workspace.list.baseline" || + verb === "workspace.list.after-new" + ) { + return "workspace.list"; + } + if (verb === "view.list.before" || verb === "view.list.after") { + return "view.list"; + } + if (verb === "terminal.list.before" || verb === "terminal.list.after") { + return "terminal.list"; + } + return verb; +} + +function ctlResultProjectionProblems( + verb: string, + envelope: CtlEnvelope, +): string[] { + if (!envelope.ok) return []; + const result = envelope.result; + const canonicalVerb = canonicalProjectionVerb(verb); + const problems: string[] = []; + const requireIdentifier = ( + value: unknown, + pattern: RegExp, + field: string, + ): void => { + if (typeof value !== "string" || !pattern.test(value)) { + problems.push(`result.${field} has an invalid identifier`); + } + }; + + switch (canonicalVerb) { + case "instance.list": { + problems.push(...projectionObjectProblems(result, ["instances"])); + const instances = isRecord(result) ? result["instances"] : undefined; + problems.push(...projectionArrayProblem(instances, "instances")); + if (Array.isArray(instances)) { + const instanceIds = new Set(); + for (const instance of instances) { + problems.push( + ...projectionRecordProblem(instance, [ + "instance", + "socket", + "live", + ]), + ); + if (isRecord(instance)) { + problems.push( + ...projectionStringProblem( + instance["instance"], + "instance", + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ), + ...projectionStringProblem(instance["socket"], "socket"), + ); + if (instance["live"] !== true) { + problems.push("result.instances contains a non-live record"); + } + if ( + typeof instance["instance"] === "string" && + instanceIds.has(instance["instance"]) + ) { + problems.push("result.instances contains a duplicate id"); + } else if (typeof instance["instance"] === "string") { + instanceIds.add(instance["instance"]); + } + } + } + } + break; + } + case "window.list": { + problems.push(...projectionObjectProblems(result, ["windows"])); + const windows = isRecord(result) ? result["windows"] : undefined; + problems.push(...projectionArrayProblem(windows, "windows")); + if (Array.isArray(windows)) { + const windowIds = new Set(); + for (const window of windows) { + problems.push(...projectionRecordProblem(window, ["id"])); + if (isRecord(window)) + requireIdentifier(window["id"], /^w:\d+$/, "windows.id"); + if ( + isRecord(window) && + typeof window["id"] === "string" && + windowIds.has(window["id"]) + ) { + problems.push("result.windows contains a duplicate id"); + } else if (isRecord(window) && typeof window["id"] === "string") { + windowIds.add(window["id"]); + } + } + } + break; + } + case "view.list": + try { + viewsFrom(envelope); + } catch { + problems.push("view list projection is invalid"); + } + break; + case "terminal.list": + try { + terminalsFrom(envelope); + } catch { + problems.push("terminal list projection is invalid"); + } + break; + case "terminal.text": + try { + const text = terminalTextFrom(envelope); + if (utf8Bytes(text) > MAX_CAMPAIGN_STRING_BYTES) { + problems.push("terminal text projection is oversized"); + } + } catch { + problems.push("terminal text projection is invalid"); + } + break; + case "workspace.list": { + problems.push( + ...projectionObjectProblems(result, [ + "workspaces", + "names", + "active", + "active_id", + "count", + "tabline", + ]), + ); + if (isRecord(result)) { + const workspaces = result["workspaces"]; + const names = result["names"]; + problems.push( + ...projectionArrayProblem(workspaces, "workspaces"), + ...projectionArrayProblem(names, "names"), + ...projectionStringProblem( + result["tabline"], + "tabline", + MAX_CAMPAIGN_STRING_BYTES, + true, + ), + ); + if (Array.isArray(workspaces)) { + const identifiers = new Set(); + for (const [index, workspace] of workspaces.entries()) { + problems.push( + ...projectionStringProblem( + workspace, + `workspaces.${index}`, + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ), + ); + if (typeof workspace === "string") { + try { + assertSafeWorkspaceId(workspace); + const canonical = canonicalWorkspaceId(workspace); + if (canonical === undefined || identifiers.has(canonical)) { + problems.push("workspace list projection has an invalid id"); + } else { + identifiers.add(canonical); + } + } catch { + problems.push("workspace list projection has an invalid id"); + } + } + } + if (Array.isArray(names)) { + if (names.length !== workspaces.length) { + problems.push("workspace names count does not match ids"); + } + for (const [index, name] of names.entries()) { + problems.push( + ...projectionStringProblem( + name, + `names.${index}`, + MAX_CAMPAIGN_STRING_BYTES, + true, + ), + ); + } + } + if ( + !Number.isSafeInteger(result["count"]) || + result["count"] !== workspaces.length + ) { + problems.push("workspace count does not match ids"); + } + if ( + !Number.isSafeInteger(result["active"]) || + (result["active"] as number) < 1 || + (result["active"] as number) > workspaces.length || + typeof result["active_id"] !== "string" || + canonicalWorkspaceId(result["active_id"]) === undefined || + !identifiers.has(canonicalWorkspaceId(result["active_id"]) ?? "") + ) { + problems.push("workspace active projection is invalid"); + } + } + } + break; + } + case "workspace.new": { + problems.push( + ...projectionObjectProblems(result, ["created", "tabline"]), + ); + if (isRecord(result)) { + problems.push( + ...projectionStringProblem( + result["created"], + "created", + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ), + ); + problems.push( + ...projectionStringProblem( + result["tabline"], + "tabline", + MAX_CAMPAIGN_STRING_BYTES, + true, + ), + ); + try { + assertSafeWorkspaceId(result["created"] as string); + } catch { + problems.push("workspace created projection is invalid"); + } + } + break; + } + case "workspace.focus": { + problems.push( + ...projectionObjectProblems(result, ["focused", "tabline"]), + ); + if (isRecord(result)) { + problems.push( + ...projectionStringProblem( + result["focused"], + "focused", + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ), + ); + problems.push( + ...projectionStringProblem( + result["tabline"], + "tabline", + MAX_CAMPAIGN_STRING_BYTES, + true, + ), + ); + try { + assertSafeWorkspaceId(result["focused"] as string); + } catch { + problems.push("workspace focus projection is invalid"); + } + } + break; + } + case "view.split": { + problems.push(...projectionObjectProblems(result, ["split", "new_view"])); + if (isRecord(result)) { + if ( + !["left", "right", "up", "down"].includes(result["split"] as string) + ) { + problems.push("view split direction is invalid"); + } + requireIdentifier(result["new_view"], VIEW_ID_RE, "new_view"); + } + break; + } + case "view.focus": { + problems.push(...projectionObjectProblems(result, ["focused"])); + if (isRecord(result)) + requireIdentifier(result["focused"], VIEW_ID_RE, "focused"); + break; + } + case "terminal.spawn": + try { + terminalSpawnedFrom(envelope); + } catch { + problems.push("terminal spawn projection is invalid"); + } + break; + case "terminal.close": { + problems.push(...projectionObjectProblems(result, ["closed"])); + if (isRecord(result)) + requireIdentifier(result["closed"], TERMINAL_ID_RE, "closed"); + break; + } + case "workspace.close": { + problems.push( + ...projectionObjectProblems(result, ["closed", "killed", "tabline"]), + ); + if (isRecord(result)) { + requireIdentifier(result["closed"], WORKSPACE_ID_RE, "closed"); + if (typeof result["killed"] !== "boolean") { + problems.push("workspace close killed projection is invalid"); + } + problems.push( + ...projectionStringProblem( + result["tabline"], + "tabline", + MAX_CAMPAIGN_STRING_BYTES, + true, + ), + ); + } + break; + } + case "terminal.send": { + problems.push(...projectionObjectProblems(result, ["sent_to", "bytes"])); + if (isRecord(result)) { + requireIdentifier(result["sent_to"], TERMINAL_ID_RE, "sent_to"); + if ( + !Number.isSafeInteger(result["bytes"]) || + (result["bytes"] as number) < 0 + ) { + problems.push("terminal send byte count is invalid"); + } + } + break; + } + case "config.reload": { + problems.push( + ...projectionObjectProblems(result, [ + "probed", + "applied", + "path", + "hot_swap", + ]), + ); + if (isRecord(result)) { + if ( + result["probed"] !== true || + result["applied"] !== false || + result["hot_swap"] !== "follow-up" + ) { + problems.push("config reload outcome projection is invalid"); + } + problems.push( + ...projectionStringProblem(result["path"], "path"), + ...projectionStringProblem(result["hot_swap"], "hot_swap", 128), + ); + } + break; + } + default: + problems.push(`result projection for ${canonicalVerb} is unavailable`); + } + return [...new Set(problems)].slice(0, 8); +} + +function assertCtlResultProjection(verb: string, envelope: CtlEnvelope): void { + const problems = ctlResultProjectionProblems(verb, envelope); + if (problems.length > 0) { + throw new CampaignError( + "MalformedEnvelope", + safeReportText( + `ctl result projection is invalid: ${problems.join("; ")}`, + ), + ); + } +} + +async function dispatchRawEnvelope( dispatcher: CtlDispatcher, invocation: CtlInvocation, ): Promise { const result = await dispatcher.dispatch(invocation); + assertBoundedCtlResult(result); if (result.timedOut) { - throw new CampaignError("EmptyOutput", `${invocation.verb} timed out`); + throw new CampaignError("EmptyOutput", "ctl invocation timed out"); + } + const envelope = parseCtlEnvelopeShape(result.stdout); + if (envelope.command !== `core.${canonicalProjectionVerb(invocation.verb)}`) { + throw new CampaignError( + "MalformedEnvelope", + "ctl envelope command does not match the invocation", + ); + } + return envelope; +} + +async function dispatchEnvelope( + dispatcher: CtlDispatcher, + invocation: CtlInvocation, +): Promise { + const envelope = await dispatchRawEnvelope(dispatcher, invocation); + assertCtlResultProjection(invocation.verb, envelope); + return envelope; +} + +type WorkspaceObservation = { + ids: string[]; + problems: number; +}; + +function observeWorkspaceIds(envelope: CtlEnvelope): WorkspaceObservation { + let problems = ctlResultProjectionProblems("workspace.list", envelope).length; + const ids: string[] = []; + if (!envelope.ok || !isRecord(envelope.result)) { + return { ids, problems: problems + 1 }; + } + const workspaces = envelope.result["workspaces"]; + if ( + !Array.isArray(workspaces) || + workspaces.length > MAX_CAMPAIGN_WORKSPACES + ) { + return { ids, problems: problems + 1 }; } - return parseCtlEnvelope(result.stdout); + const seen = new Set(); + for (const workspace of workspaces) { + if (typeof workspace !== "string") { + problems += 1; + continue; + } + const canonical = canonicalWorkspaceId(workspace); + if (canonical === undefined) { + problems += 1; + continue; + } + if (seen.has(canonical)) { + problems += 1; + continue; + } + seen.add(canonical); + ids.push(canonical); + } + return { ids, problems }; } /** @@ -1015,12 +2130,13 @@ async function dispatchEnvelope( */ export async function probeWorkspaceIdRoundTrip( dispatcher: CtlDispatcher, - opts: { elevated?: boolean } = {}, + _opts: { elevated?: boolean } = {}, ): Promise { const name = "workspace:id-round-trip"; const evidence: string[] = []; const problems: string[] = []; - let owned: string | undefined; + const declared = new Set(); + const owned = new Set(); let count = 0; try { const listed = workspaceNamesFrom( @@ -1030,97 +2146,129 @@ export async function probeWorkspaceIdRoundTrip( elevated: false, }), ); - evidence.push(`baseline=[${listed.join(",")}]`); - const baseline = new Set( - listed.map((id) => { - assertSafeWorkspaceId(id); - return id.replace(/^ws:?0*(?=\d)/, "ws:"); - }), - ); - - const created = workspaceCreatedFrom( - await dispatchEnvelope(dispatcher, { - verb: "workspace.new", - args: ["workspace", "new", "--format", "json"], - elevated: false, - }), - ); - evidence.push(`created=${created}`); - if (!WORKSPACE_ID_RE.test(created)) { - throw new CampaignError( - "MissingField", - `workspace new created non-id '${created}'`, - ); + evidence.push(`baseline.count=${listed.length}`); + const baseline = new Set(); + for (const identifier of listed) { + const canonical = canonicalWorkspaceId(identifier); + if (canonical === undefined) { + throw new CampaignError( + "MissingField", + "workspace identifier is invalid", + ); + } + baseline.add(canonical); } - if (baseline.has(created.replace(/^ws:?0*(?=\d)/, "ws:"))) { - throw new CampaignError( - "MissingField", - "workspace new returned a pre-existing id", + + try { + const created = workspaceCreatedFrom( + await dispatchEnvelope(dispatcher, { + verb: "workspace.new", + args: ["workspace", "new", "--format", "json"], + elevated: false, + }), ); + const canonical = canonicalWorkspaceId(created); + if (canonical === undefined) { + problems.push("workspace new projection is invalid"); + } else if (baseline.has(canonical)) { + problems.push("workspace new reported a baseline identifier"); + } else { + declared.add(canonical); + owned.add(canonical); + evidence.push("created=true"); + } + } catch (error) { + problems.push(campaignFailureMessage(error)); } - owned = created; - const afterNew = workspaceNamesFrom( - await dispatchEnvelope(dispatcher, { + const observation = observeWorkspaceIds( + await dispatchRawEnvelope(dispatcher, { verb: "workspace.list.after-new", args: ["workspace", "list", "--format", "json"], elevated: false, }), ); - evidence.push(`afterNew=[${afterNew.join(",")}]`); - - count = afterNew.length; - if (afterNew.length === 0) { - problems.push("workspace list empty after new"); + count = observation.ids.length; + evidence.push(`afterNew.count=${count}`); + if (observation.problems > 0) { + problems.push("workspace post-create projection is invalid"); } - for (const identifier of afterNew) { - try { - assertSafeWorkspaceId(identifier); - } catch { - problems.push(`listed id '${identifier}' is not a workspace id`); - continue; + const observedOwned = new Set(); + for (const identifier of observation.ids) { + if (baseline.has(identifier)) continue; + owned.add(identifier); + observedOwned.add(identifier); + if (!declared.has(identifier)) { + problems.push("workspace list contained an unexpected new identifier"); } - let accepted = false; - const candidates = workspaceIdCandidates(identifier); - for (const candidate of candidates) { - const focused = await dispatchEnvelope(dispatcher, { - verb: "workspace.focus", - args: ["workspace", "focus", candidate, "--format", "json"], - elevated: false, - }); - if (focused.ok) { - accepted = true; - evidence.push(`focus(${candidate})=ok`); - break; + } + if ( + declared.size > 0 && + [...declared].some((identifier) => !observedOwned.has(identifier)) + ) { + problems.push("workspace create response was not observed"); + } + if (observation.ids.length === 0) { + problems.push("workspace list empty after new"); + } + + if (observation.problems === 0) { + for (const [index, identifier] of observation.ids.entries()) { + let accepted = false; + for (const candidate of workspaceIdCandidates(identifier)) { + const focused = await dispatchEnvelope(dispatcher, { + verb: "workspace.focus", + args: ["workspace", "focus", candidate, "--format", "json"], + elevated: false, + }); + const returned = + focused.ok && isRecord(focused.result) + ? focused.result["focused"] + : undefined; + if ( + focused.ok && + typeof returned === "string" && + canonicalWorkspaceId(returned) === canonicalWorkspaceId(candidate) + ) { + accepted = true; + evidence.push(`focus.${index}=ok`); + break; + } + if (focused.ok) { + evidence.push(`focus.${index}=mismatch`); + } + evidence.push(`focus.${index}=rejected`); + } + if (!accepted) { + problems.push(`workspace identifier at index ${index} was rejected`); } - evidence.push( - `focus(${candidate})=${focused.error.class}/${focused.error.code}`, - ); - } - if (!accepted) { - problems.push(`listed id ${identifier} rejected by focus`); } } - } catch (err) { - problems.push(campaignFailureMessage(err)); + } catch (error) { + problems.push(campaignFailureMessage(error)); } finally { - if (opts.elevated === true && owned !== undefined) { + for (const identifier of [...owned].sort()) { try { const closed = await dispatchEnvelope(dispatcher, { verb: "workspace.close", - args: ["workspace", "close", owned, "--format", "json"], + args: ["workspace", "close", identifier, "--format", "json"], elevated: true, }); - if (!closed.ok) { - problems.push( - `owned id ${owned} rejected by close (${closed.error.class}/${closed.error.code})`, - ); + if ( + closed.ok && + isRecord(closed.result) && + typeof closed.result["closed"] === "string" && + canonicalWorkspaceId(closed.result["closed"]) === identifier + ) { + evidence.push("owned.cleanup=ok"); + } else if (!closed.ok && closed.error.code === "NotFound") { + evidence.push("owned.cleanup=already-absent"); } else { - evidence.push(`close(${owned})=ok`); + problems.push("owned workspace cleanup response did not match"); } - } catch (err) { + } catch (error) { problems.push( - `owned workspace cleanup failed: ${campaignFailureMessage(err)}`, + `owned workspace cleanup failed: ${campaignFailureMessage(error)}`, ); } } @@ -1148,12 +2296,22 @@ export function terminalTextFrom(envelope: CtlEnvelope): string { throw new CampaignError("MissingField", "terminal text returned an error"); } const result = envelope.result; - if (!isRecord(result) || typeof result["text"] !== "string") { + if ( + !isRecord(result) || + projectionObjectProblems(result, ["terminal_id", "text"]).length > 0 || + typeof result["terminal_id"] !== "string" || + !TERMINAL_ID_RE.test(result["terminal_id"]) + ) { throw new CampaignError( "MissingField", - "terminal text result.text missing", + "terminal text result projection is invalid", ); } + assertBoundedString( + "terminal text", + result["text"], + MAX_CAMPAIGN_STRING_BYTES, + ); return result["text"]; } @@ -1166,6 +2324,9 @@ export async function probeTerminalTextShape( terminalId = "t:1", ): Promise { const name = "terminal:text-shape"; + if (!TERMINAL_ID_RE.test(terminalId)) { + return fail(name, "terminal text target is invalid"); + } try { const envelope = await dispatchEnvelope(dispatcher, { verb: "terminal.text", @@ -1177,15 +2338,15 @@ export async function probeTerminalTextShape( return fail( name, `terminal text looks like a Rust Debug dump (${text.length} chars)`, - [`terminal=${terminalId}`, `preview=${text.slice(0, 120)}`], + ["target=redacted"], ); } return pass(name, `plain grid text (${text.length} chars)`, [ - `terminal=${terminalId}`, + "target=validated", `lines=${text.split("\n").length}`, ]); - } catch (err) { - return fail(name, campaignFailureMessage(err), [`terminal=${terminalId}`]); + } catch (error) { + return fail(name, campaignFailureMessage(error)); } } @@ -1193,21 +2354,71 @@ export async function probeTerminalTextShape( // Probe 4: terminal spawn observability (D3 guard) // --------------------------------------------------------------------------- +type ViewRecord = { + id: string; + focused: boolean; +}; + type TerminalSummary = { - views: string[]; + views: ViewRecord[]; terminals: string[]; paneSessions: boolean[]; + focusedView: string | undefined; }; -function viewsFrom(envelope: CtlEnvelope): string[] { +function viewsFrom(envelope: CtlEnvelope): ViewRecord[] { if (!envelope.ok) throw new CampaignError("MissingField", "view list error"); const result = envelope.result; - if (!isRecord(result) || !Array.isArray(result["views"])) { + if ( + !isRecord(result) || + projectionObjectProblems(result, ["views"]).length > 0 || + !Array.isArray(result["views"]) + ) { throw new CampaignError("MissingField", "view list result.views missing"); } - return result["views"] - .map((v) => (isRecord(v) ? v["id"] : undefined)) - .filter((v): v is string => typeof v === "string"); + if (result["views"].length > MAX_CAMPAIGN_ARRAY_ITEMS) { + throw new CampaignError( + "OutputTooLarge", + `view list exceeds ${MAX_CAMPAIGN_ARRAY_ITEMS} items`, + ); + } + const views: ViewRecord[] = []; + const seen = new Set(); + for (const entry of result["views"]) { + if (!isRecord(entry)) { + throw new CampaignError( + "MalformedEnvelope", + "view list contains a malformed record", + ); + } + const problems = unexpectedEnvelopeFields(entry, ["id", "focused"]); + if (problems.length > 0 || typeof entry["focused"] !== "boolean") { + throw new CampaignError( + "MalformedEnvelope", + "view list record is invalid", + ); + } + assertBoundedString( + "view identifier", + entry["id"], + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); + if (!VIEW_ID_RE.test(entry["id"])) { + throw new CampaignError( + "MalformedEnvelope", + "view identifier is invalid", + ); + } + if (seen.has(entry["id"])) { + throw new CampaignError( + "MalformedEnvelope", + "view list contains a duplicate identifier", + ); + } + seen.add(entry["id"]); + views.push({ id: entry["id"], focused: entry["focused"] }); + } + return views; } function terminalsFrom(envelope: CtlEnvelope): { @@ -1217,22 +2428,111 @@ function terminalsFrom(envelope: CtlEnvelope): { if (!envelope.ok) throw new CampaignError("MissingField", "terminal list error"); const result = envelope.result; - if (!isRecord(result) || !Array.isArray(result["terminals"])) { + if ( + !isRecord(result) || + projectionObjectProblems(result, ["terminals"]).length > 0 || + !Array.isArray(result["terminals"]) + ) { throw new CampaignError( "MissingField", "terminal list result.terminals missing", ); } + if (result["terminals"].length > MAX_CAMPAIGN_ARRAY_ITEMS) { + throw new CampaignError( + "OutputTooLarge", + `terminal list exceeds ${MAX_CAMPAIGN_ARRAY_ITEMS} items`, + ); + } const ids: string[] = []; const paneSessions: boolean[] = []; + const seen = new Set(); for (const entry of result["terminals"]) { - if (!isRecord(entry)) continue; - if (typeof entry["id"] === "string") ids.push(entry["id"]); - paneSessions.push(entry["has_pane_session"] === true); + if (!isRecord(entry)) { + throw new CampaignError( + "MalformedEnvelope", + "terminal list contains a malformed record", + ); + } + const problems = unexpectedEnvelopeFields(entry, [ + "id", + "has_pane_session", + ]); + if (problems.length > 0 || typeof entry["has_pane_session"] !== "boolean") { + throw new CampaignError( + "MalformedEnvelope", + "terminal list record is invalid", + ); + } + assertBoundedString( + "terminal identifier", + entry["id"], + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); + if (!TERMINAL_ID_RE.test(entry["id"])) { + throw new CampaignError( + "MalformedEnvelope", + "terminal identifier is invalid", + ); + } + if (seen.has(entry["id"])) { + throw new CampaignError( + "MalformedEnvelope", + "terminal list contains a duplicate identifier", + ); + } + seen.add(entry["id"]); + ids.push(entry["id"]); + paneSessions.push(entry["has_pane_session"]); } return { ids, paneSessions }; } +function terminalSpawnedFrom(envelope: CtlEnvelope): { + terminalId: string; + viewId: string; +} { + if (!envelope.ok) { + throw new CampaignError("MissingField", "terminal spawn returned an error"); + } + const result = envelope.result; + if (!isRecord(result)) { + throw new CampaignError("MissingField", "terminal spawn result is missing"); + } + const problems = unexpectedEnvelopeFields(result, [ + "spawned", + "terminal_id", + "view_id", + ]); + if ( + problems.length > 0 || + result["spawned"] !== true || + typeof result["terminal_id"] !== "string" || + typeof result["view_id"] !== "string" || + !TERMINAL_ID_RE.test(result["terminal_id"]) || + !VIEW_ID_RE.test(result["view_id"]) + ) { + throw new CampaignError( + "MalformedEnvelope", + "terminal spawn result is invalid", + ); + } + assertBoundedString( + "spawned terminal identifier", + result["terminal_id"], + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); + assertBoundedString( + "spawned view identifier", + result["view_id"], + MAX_CAMPAIGN_IDENTIFIER_BYTES, + ); + return { + terminalId: result["terminal_id"], + viewId: result["view_id"], + }; +} + async function terminalSummary( dispatcher: CtlDispatcher, phase: string, @@ -1248,13 +2548,80 @@ async function terminalSummary( elevated: false, }); const terminals = terminalsFrom(terminalEnvelope); + const views = viewsFrom(viewEnvelope); + const terminalIds = new Set(terminals.ids); + if ( + views.length !== terminalIds.size || + views.some((view) => !terminalIds.has(`t:${view.id.slice(2)}`)) + ) { + throw new CampaignError( + "MalformedEnvelope", + "view and terminal lists are inconsistent", + ); + } + const focused = views.filter((view) => view.focused); + if (focused.length > 1) { + throw new CampaignError( + "MalformedEnvelope", + "view list contains multiple focused records", + ); + } return { - views: viewsFrom(viewEnvelope), + views, terminals: terminals.ids, paneSessions: terminals.paneSessions, + focusedView: focused[0]?.id, }; } +type TerminalObservation = { + ids: string[]; + paneSessions: Map; + problems: number; +}; + +function observeTerminalIds(envelope: CtlEnvelope): TerminalObservation { + let problems = ctlResultProjectionProblems("terminal.list", envelope).length; + const ids: string[] = []; + const paneSessions = new Map(); + if (!envelope.ok || !isRecord(envelope.result)) { + return { ids, paneSessions, problems: problems + 1 }; + } + const terminals = envelope.result["terminals"]; + if ( + !Array.isArray(terminals) || + terminals.length > MAX_CAMPAIGN_ARRAY_ITEMS + ) { + return { ids, paneSessions, problems: problems + 1 }; + } + const seen = new Set(); + for (const terminal of terminals) { + if (!isRecord(terminal)) { + problems += 1; + continue; + } + const id = terminal["id"]; + const paneSession = terminal["has_pane_session"]; + if ( + typeof id !== "string" || + !TERMINAL_ID_RE.test(id) || + utf8Bytes(id) > MAX_CAMPAIGN_IDENTIFIER_BYTES || + typeof paneSession !== "boolean" + ) { + problems += 1; + continue; + } + if (seen.has(id)) { + problems += 1; + continue; + } + seen.add(id); + ids.push(id); + paneSessions.set(id, paneSession); + } + return { ids, paneSessions, problems }; +} + /** * D3 guard: `terminal spawn` reporting success must be observable in * `view list` / `terminal list` (new id) or in `has_pane_session` flipping. @@ -1265,58 +2632,169 @@ export async function probeTerminalSpawnObservability( ): Promise { const name = "terminal:spawn-observable"; const evidence: string[] = []; + const problems: string[] = []; + const declared = new Set(); + const owned = new Set(); + let previousFocus: string | undefined; + let baselineTerminals: ReadonlySet = new Set(); + let baselineViews: ReadonlySet = new Set(); try { const before = await terminalSummary(dispatcher, "before"); + baselineTerminals = new Set(before.terminals); + baselineViews = new Set(before.views.map((view) => view.id)); + previousFocus = before.focusedView; evidence.push( `before.views=${before.views.length}`, `before.terminals=${before.terminals.length}`, ); - const spawned = await dispatchEnvelope(dispatcher, { - verb: "terminal.spawn", - args: ["terminal", "spawn", "--format", "json"], - elevated: opts.elevated ?? true, - }); - if (!spawned.ok) { - return fail( - name, - `spawn failed: ${spawned.error.class}/${spawned.error.code}`, - evidence, - ); + try { + const spawned = await dispatchEnvelope(dispatcher, { + verb: "terminal.spawn", + args: ["terminal", "spawn", "--format", "json"], + elevated: opts.elevated ?? true, + }); + if (!spawned.ok) { + problems.push("terminal spawn returned an error"); + } else { + const created = terminalSpawnedFrom(spawned); + if (baselineTerminals.has(created.terminalId)) { + problems.push("terminal spawn reported a baseline resource"); + } else { + declared.add(created.terminalId); + owned.add(created.terminalId); + if ( + baselineViews.has(created.viewId) || + created.terminalId.slice(2) !== created.viewId.slice(2) + ) { + problems.push("terminal spawn returned inconsistent identifiers"); + } + evidence.push("spawned=true"); + } + } + } catch (error) { + problems.push(campaignFailureMessage(error)); } - evidence.push("spawned=true"); - const after = await terminalSummary(dispatcher, "after"); - evidence.push( - `after.views=${after.views.length}`, - `after.terminals=${after.terminals.length}`, - ); - evidence.push( - `paneSession.before=${before.paneSessions.join(",")}`, - `paneSession.after=${after.paneSessions.join(",")}`, + const terminalObservation = observeTerminalIds( + await dispatchRawEnvelope(dispatcher, { + verb: "terminal.list.after", + args: ["terminal", "list", "--format", "json"], + elevated: false, + }), ); + evidence.push(`after.terminals=${terminalObservation.ids.length}`); + if (terminalObservation.problems > 0) { + problems.push("terminal post-create projection is invalid"); + } + const observedOwned = new Set(); + for (const identifier of terminalObservation.ids) { + if (baselineTerminals.has(identifier)) continue; + owned.add(identifier); + observedOwned.add(identifier); + if (!declared.has(identifier)) { + problems.push("terminal list contained an unexpected new identifier"); + } + } + if ( + declared.size > 0 && + [...declared].some((identifier) => !observedOwned.has(identifier)) + ) { + problems.push("terminal spawn response was not observed"); + } - const newView = after.views.some((id) => !before.views.includes(id)); - const newTerminal = after.terminals.some( - (id) => !before.terminals.includes(id), - ); - const paneFlipped = - after.paneSessions.some((v) => v) && !before.paneSessions.some((v) => v); - if (!newView && !newTerminal && !paneFlipped) { - return fail( - name, - "spawn reported success but no view/terminal/has_pane_session change", - evidence, + try { + const afterViews = viewsFrom( + await dispatchRawEnvelope(dispatcher, { + verb: "view.list.after", + args: ["view", "list", "--format", "json"], + elevated: false, + }), + ); + evidence.push(`after.views=${afterViews.length}`); + const viewIds = new Set(afterViews.map((view) => view.id)); + const declaredViewIds = new Set( + [...declared].map((identifier) => `v:${identifier.slice(2)}`), ); + if ( + afterViews.some( + (view) => + !baselineViews.has(view.id) && !declaredViewIds.has(view.id), + ) + ) { + problems.push("view list contained an unexpected new identifier"); + } + for (const identifier of declared) { + const viewId = `v:${identifier.slice(2)}`; + if ( + !viewIds.has(viewId) || + terminalObservation.paneSessions.get(identifier) !== true + ) { + problems.push( + "spawn reported success but the created resource was not observable", + ); + } + } + } catch (error) { + problems.push(campaignFailureMessage(error)); + } + } catch (error) { + problems.push(campaignFailureMessage(error)); + } finally { + for (const identifier of [...owned].sort()) { + try { + const closed = await dispatchEnvelope(dispatcher, { + verb: "terminal.close", + args: ["terminal", "close", identifier, "--format", "json"], + elevated: true, + }); + if ( + closed.ok && + isRecord(closed.result) && + closed.result["closed"] === identifier + ) { + evidence.push("owned.terminal.cleanup=ok"); + } else if (!closed.ok && closed.error.code === "NotFound") { + evidence.push("owned.terminal.cleanup=already-absent"); + } else { + problems.push("owned terminal cleanup response did not match"); + } + } catch (error) { + problems.push( + `owned terminal cleanup failed: ${campaignFailureMessage(error)}`, + ); + } + } + if (previousFocus !== undefined) { + try { + const focused = await dispatchEnvelope(dispatcher, { + verb: "view.focus", + args: ["view", "focus", previousFocus, "--format", "json"], + elevated: false, + }); + if ( + focused.ok && + isRecord(focused.result) && + focused.result["focused"] === previousFocus + ) { + evidence.push("baseline.focus.restored=true"); + } else { + problems.push("baseline focus restoration response did not match"); + } + } catch (error) { + problems.push( + `baseline focus restoration failed: ${campaignFailureMessage(error)}`, + ); + } } - return pass( - name, - "spawn is observable in view/terminal list or pane session", - evidence, - ); - } catch (err) { - return fail(name, campaignFailureMessage(err), evidence); } + return problems.length > 0 + ? fail(name, problems.join("; "), evidence) + : pass( + name, + "spawn is observable and every run-owned terminal was cleaned", + evidence, + ); } // --------------------------------------------------------------------------- @@ -1444,16 +2922,18 @@ export function probeSocketDirPreflight( ): ProbeResult { const name = "socket:parent-dir-0700"; if (result.ok) { - return pass(name, `parent ${result.parentDir} is 0700 and owner-matched`, [ + return pass(name, "parent directory is 0700 and owner-matched", [ `mode=${result.mode === null ? "?" : dirModeOctal(result.mode)}`, ]); } - const diagnostic = result.diagnostic ?? "socket preflight failed"; - const detail = - result.remedy === null ? diagnostic : `${diagnostic}; ${result.remedy}`; - return fail(name, detail, [ - result.remedy === null ? "" : `remedy=${result.remedy}`, - ]); + if (result.mode !== null) { + return fail( + name, + "socket parent mode must be 0700; chmod 700 is required", + [`mode=${dirModeOctal(result.mode)}`], + ); + } + return fail(name, "socket parent preflight failed", ["path=redacted"]); } // --------------------------------------------------------------------------- @@ -1523,15 +3003,26 @@ export type CampaignReport = { export function summarizeCampaign( results: readonly ProbeResult[], ): CampaignReport { + const bounded = results + .slice(0, MAX_CAMPAIGN_REPORT_RESULTS) + .map(normalizeProbeResult); + if (results.length > MAX_CAMPAIGN_REPORT_RESULTS) { + bounded.push( + fail( + "campaign:report-limit", + `campaign report exceeds ${MAX_CAMPAIGN_REPORT_RESULTS} results`, + ), + ); + } let passed = 0; let failed = 0; let skipped = 0; - for (const result of results) { + for (const result of bounded) { if (result.status === "pass") passed += 1; else if (result.status === "fail") failed += 1; else skipped += 1; } - return { results, passed, failed, skipped, ok: failed === 0 }; + return { results: bounded, passed, failed, skipped, ok: failed === 0 }; } export type CampaignOptions = { @@ -1545,7 +3036,7 @@ export type CampaignOptions = { stat: (dir: string) => SocketDirStat | null; requiredMode?: number; }; - /** Set true to also exercise workspace `close` (destructive; live only). */ + /** Legacy explicit destructive-admission flag; owned cleanup is unconditional. */ closeWorkspaces?: boolean; /** Override the verb matrix (tests inject focused matrices). */ matrix?: readonly VerbExpectation[]; @@ -1569,6 +3060,16 @@ export type CampaignOptions = { export async function runCampaign( options: CampaignOptions, ): Promise { + const providedMatrix: unknown = Object.hasOwn(options, "matrix") + ? options.matrix + : CTL_VERB_MATRIX; + const matrixProblem = campaignMatrixProblem(providedMatrix); + if (matrixProblem !== undefined) { + return summarizeCampaign([ + fail(campaignMatrixFailureName(providedMatrix), matrixProblem), + ]); + } + const sourceMatrix = providedMatrix as readonly VerbExpectation[]; const results: ProbeResult[] = []; if (options.socket !== undefined) { try { @@ -1612,19 +3113,33 @@ export async function runCampaign( return summarizeCampaign(results); } const allowKeystrokes = keystrokeProbeOptIn(options.keystrokeTarget); + if (allowKeystrokes && sourceMatrix.length >= MAX_CAMPAIGN_MATRIX_ROWS) { + return summarizeCampaign([ + fail( + "campaign:matrix-limit", + `campaign matrix cannot append keystroke row beyond ${MAX_CAMPAIGN_MATRIX_ROWS} rows`, + ), + ]); + } const matrix = allowKeystrokes && options.keystrokeTarget !== undefined - ? [ - ...(options.matrix ?? CTL_VERB_MATRIX), - keystrokeProbeExpectation(options.keystrokeTarget), - ] - : (options.matrix ?? CTL_VERB_MATRIX); + ? [...sourceMatrix, keystrokeProbeExpectation(options.keystrokeTarget)] + : sourceMatrix; const admittedMatrix = matrix.filter((row) => { if (row.args[1] === "close") { results.push( skip( `envelope:${row.verb}`, - "close requires a run-owned identifier; exercised by workspace cleanup only", + "close requires a run-owned identifier; exercised by owned-resource cleanup only", + ), + ); + return false; + } + if (row.verb === "workspace.new" || row.verb === "terminal.spawn") { + results.push( + skip( + `envelope:${row.verb}`, + "owned resource creation is exercised by the cleanup probe", ), ); return false; @@ -1663,9 +3178,7 @@ export async function runCampaign( ); results.push( allowMutations - ? await probeWorkspaceIdRoundTrip(options.dispatcher, { - elevated: options.closeWorkspaces ?? false, - }) + ? await probeWorkspaceIdRoundTrip(options.dispatcher) : skip("workspace:id-round-trip", "requires disposable-instance consent"), ); results.push( @@ -1695,7 +3208,7 @@ export type LiveCampaignConfig = ProcessDispatcherConfig & { runtimeUid?: number; /** Injectable stat for the preflight; omit to skip the preflight probe. */ stat?: (dir: string) => SocketDirStat | null; - /** Set true to also exercise workspace `close` (destructive; live only). */ + /** Legacy explicit destructive-admission flag; owned cleanup is unconditional. */ closeWorkspaces?: boolean; /** * Explicit opt-in for the keystroke-injection probe. Absent by default, so diff --git a/src/redaction.ts b/src/redaction.ts index 71561ba..e9e6bc4 100644 --- a/src/redaction.ts +++ b/src/redaction.ts @@ -158,3 +158,198 @@ export function assertPreviewEqualsExport( ); } } + +/* ------------------------------------------------------------------------ * + * Normalization class + * + * NORM-1 (normative, mirrored in crates/devtools-client/src/redaction.rs): + * the normalization class is every code point above U+007F that Unicode + * classifies as Default_Ignorable_Code_Point, as general category Cf + * (Other_Format), or as White_Space. Membership is decided by Unicode + * character properties only; no hand-written range list is normative. + * + * Rationale: every member renders as nothing at all (a format control or a + * default-ignorable code point) or as blank (a non-ASCII space separator), so + * a hostile producer can inject any of them to break a literal credential + * pattern match without changing what the operator sees on screen. They are + * therefore removed before secret matching and before human rendering. + * Membership is 4225 code points in 29 ranges for Unicode 17.0 and is pinned + * by tests/fixtures/redaction-normalization-class.txt, which both language + * test suites execute. + * + * C0, DEL, and C1 controls are deliberately NOT in the class: they are + * escaped for rendering, not silently deleted, so an escape is never + * swallowed. U+0085 is the one code point in both sets (Cc and White_Space); + * the escape branch runs first for rendering, and both implementations + * remove it for matching. + * ---------------------------------------------------------------------- */ + +const UNICODE_DEFAULT_IGNORABLE = /\p{Default_Ignorable_Code_Point}/u; +const UNICODE_OTHER_FORMAT = /\p{Cf}/u; +const UNICODE_WHITE_SPACE = /\p{White_Space}/u; + +/** True when `codePoint` belongs to the NORM-1 normalization class. */ +export function isNormalizationSeparator(codePoint: number): boolean { + if ( + !Number.isInteger(codePoint) || + codePoint <= 0x7f || + codePoint > 0x10ffff + ) { + return false; + } + const character = String.fromCodePoint(codePoint); + return ( + UNICODE_DEFAULT_IGNORABLE.test(character) || + UNICODE_OTHER_FORMAT.test(character) || + UNICODE_WHITE_SPACE.test(character) + ); +} + +function isControlCodePoint(codePoint: number): boolean { + return ( + codePoint <= 0x1f || + codePoint === 0x7f || + (codePoint >= 0x80 && codePoint <= 0x9f) + ); +} + +/** + * Escape C0, DEL, and C1 controls, drop the NORM-1 normalization class, and + * cap the result at `maxBytes`. Nothing from the normalization class can + * survive, so a report can never smuggle an invisible code point. + */ +export function sanitizeTerminalOutput( + value: string, + maxBytes: number = BOUNDS.PREVIEW_MAX_BYTES, +): string { + if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) { + throw new Error("maxBytes must be a non-negative safe integer"); + } + const escaped = Array.from(value, (character) => { + const codePoint = character.codePointAt(0); + if (codePoint === undefined) return character; + if (codePoint === 0x0a) return "\\n"; + if (codePoint === 0x0d) return "\\r"; + if (codePoint === 0x09) return "\\t"; + if (isControlCodePoint(codePoint)) { + return `\\u${codePoint.toString(16).padStart(4, "0")}`; + } + if (isNormalizationSeparator(codePoint)) return ""; + return character; + }).join(""); + return truncateToBytes(escaped, maxBytes); +} + +/** + * Control-stripped text plus a map back to source UTF-16 offsets, so a match + * found in the stripped text can be replaced in the original string and the + * matcher's own semantics never depend on the class. + */ +type ControlNormalizedText = { + text: string; + sourceIndexes: number[]; +}; + +function controlNormalizedText(value: string): ControlNormalizedText { + let text = ""; + const sourceIndexes: number[] = []; + for (let index = 0; index < value.length;) { + const codePoint = value.codePointAt(index); + if (codePoint === undefined) break; + const width = codePoint > 0xffff ? 2 : 1; + if (isControlCodePoint(codePoint) || isNormalizationSeparator(codePoint)) { + index += width; + continue; + } + text += value.slice(index, index + width); + for (let unit = 0; unit < width; unit += 1) { + sourceIndexes.push(index + unit); + } + index += width; + } + return { text, sourceIndexes }; +} + +/** + * Assignment and bearer shapes that expose a credential inline. Matching is + * ASCII-case-insensitive: `Authorization:`, `AUTHORIZATION =`, and + * `aUtHoRiZaTiOn:` are the same finding, and the case-insensitive verification + * is reachable for every ASCII spelling of the first byte of every key. The key + * list matches the Rust `KEYS` table in `crates/devtools-client/src/redaction.rs` + * so neither implementation is weaker than the other on an assignment, and the + * delimiter tolerance matches Rust `is_assignment_after` exactly: one optional + * `-` or `_`, optional spaces and tabs, then `:` or `=`, optional spaces and + * tabs, then a non-space byte. Space and tab are the only whitespace that can + * reach this pattern, because normalization has already removed every other + * whitespace code point. Neither alternative is anchored on a word boundary, + * because a credential name is routinely glued to a prefix by `_` or `-` + * (`session_token: v`, `x-api-key: v`) and Rust has no anchor either. A longer + * word is still not a finding, because the delimiter is what terminates the + * key: `passwords: v` and `authorizationing: note` do not match. + */ +function assignmentOrBearerPattern(): RegExp { + return /(?:proxy[-_]?authorization|authorization|api[_-]?key|access[-_]?token|auth[-_]?token|auth|cookie|credential|password|passwd|secret|token)[-_]?[ \t]*[:=][ \t]*(?:"[^"]*"|'[^']*'|(?:bearer[ \t]+)?[^\s,;]+)|bearer(?:[ \t]+[^\s,;]+|[a-z0-9._~+\/=-]{8,})/giu; +} + +/** + * A bare credential-bearing configuration name (`GITHUB_TOKEN`, `API_KEY`, + * `MY_SECRET_VALUE`) is itself sensitive even with no value beside it. + * + * Deliberately case-SENSITIVE on the credential name: only the SCREAMING_SNAKE + * spelling of SECRET, TOKEN, PASSWORD, CREDENTIAL, and API_KEY is a finding. + * Running this rule case-insensitively made ordinary prose a finding, so + * "the password is required to log in" and "Tokens expire after one hour" + * were redacted while the lowercase keys they mention are not secrets. The + * case-insensitive rule that *is* wanted lives in + * {@link assignmentOrBearerPattern}, which requires an assignment. + * + * The negative lookahead keeps the rule from double-reporting a name that is + * already followed by its value: `MY_SECRET: v` is handled by the assignment + * rule, which replaces the whole `key: value` run. + */ +function credentialNamePattern(): RegExp { + return /\b(?:[A-Za-z0-9]+[_-])*(?:SECRET|TOKEN|PASSWORD|CREDENTIAL|API_KEY)(?:[_-][A-Za-z0-9]+)*\b(?!\s*[:=])/gu; +} + +function collectSecretRanges(text: string): Array<[number, number]> { + const ranges: Array<[number, number]> = []; + for (const pattern of [ + assignmentOrBearerPattern(), + credentialNamePattern(), + ]) { + let match: RegExpExecArray | null; + while ((match = pattern.exec(text)) !== null) { + if (match[0].length === 0) { + pattern.lastIndex += 1; + continue; + } + ranges.push([match.index, match.index + match[0].length]); + } + } + return ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]); +} + +function redactTypedSecretRanges(value: string): string { + const normalized = controlNormalizedText(value); + let cursor = 0; + let redacted = ""; + for (const [normalizedStart, normalizedEnd] of collectSecretRanges( + normalized.text, + )) { + const start = normalized.sourceIndexes[normalizedStart] ?? value.length; + const end = normalized.sourceIndexes[normalizedEnd] ?? value.length; + if (start < cursor) continue; + redacted += `${value.slice(cursor, start)}[REDACTED]`; + cursor = end; + } + return `${redacted}${value.slice(cursor)}`; +} + +/** + * Inline credential redaction for a free-form human-facing string. The whole + * string is replaced by the match range so an embedded secret cannot survive + * in any part of the rendered report. + */ +export function redactSensitiveText(value: string): string { + return redactTypedSecretRanges(value); +} diff --git a/tests/campaign.test.ts b/tests/campaign.test.ts index 19f8fe4..b9aaee8 100644 --- a/tests/campaign.test.ts +++ b/tests/campaign.test.ts @@ -1,10 +1,11 @@ import { describe, expect, test } from "bun:test"; +import * as campaignModule from "../src/campaign.js"; import { + CAMPAIGN_CHILD_ENV_ALLOWLIST, CTL_VERB_MATRIX, KEYSTROKE_PROBE_PAYLOAD, KEYSTROKE_PROBE_VERB, CampaignError, - DEFAULT_ELEVATION_SCOPES, EXIT_CONFLICT, assertKeystrokeProbeTarget, assertSafeWorkspaceId, @@ -14,9 +15,15 @@ import { EXIT_RUNTIME, EXIT_TIMEOUT, EXIT_USAGE, + MAX_CAMPAIGN_ARRAY_ITEMS, + MAX_CAMPAIGN_MATRIX_ROWS, + MAX_CAMPAIGN_OUTPUT_BYTES, + MAX_CAMPAIGN_REPORT_EVIDENCE_ITEMS, + MAX_CAMPAIGN_REPORT_RESULTS, NO_INSTANCE_VIEW_LIST, ProcessCtlDispatcher, ScriptedCtlDispatcher, + buildCampaignChildEnvironment, detectDebugDump, expectedExitForError, isKeystrokeProbeRow, @@ -37,7 +44,6 @@ import { probeWorkspaceIdRoundTrip, runCampaign, summarizeCampaign, - terminalTextFrom, validateEnvelopeShape, workspaceCreatedFrom, workspaceIdCandidates, @@ -47,6 +53,12 @@ import { type ProcessDispatcherConfig, type SocketDirStat, } from "../src/campaign.js"; +import { ProtocolErrorImpl, decodeResponse } from "../src/protocol.js"; +import { + isNormalizationSeparator, + redactSensitiveText, + sanitizeTerminalOutput, +} from "../src/redaction.js"; const DENIED = { class: "Denied", @@ -61,24 +73,231 @@ const UNAVAILABLE = { }; const NOTFOUND = { class: "NotFound", code: "NotFound", message: "missing" }; +function workspaceListResult(workspaces: string[], activeIndex: number) { + return { + workspaces, + names: workspaces.map(() => ""), + active: activeIndex, + active_id: workspaces[activeIndex - 1] ?? "", + count: workspaces.length, + tabline: "", + }; +} + +function successResultFor(verb: string): Record { + switch (verb) { + case "instance.list": + return { instances: [] }; + case "window.list": + return { windows: [{ id: "w:1" }] }; + case "view.list": + return { views: [{ id: "v:1", focused: true }] }; + case "terminal.list": + return { terminals: [{ id: "t:1", has_pane_session: false }] }; + case "terminal.text": + return { terminal_id: "t:1", text: "$ echo hi\nhi\n" }; + case "workspace.list": + return workspaceListResult(["ws:1"], 1); + case "workspace.new": + return { created: "ws:2", tabline: "" }; + case "workspace.focus": + return { focused: "ws:2", tabline: "" }; + case "view.split": + return { split: "right", new_view: "v:2" }; + case "view.focus": + return { focused: "v:1" }; + case "terminal.spawn": + return { spawned: true, terminal_id: "t:2", view_id: "v:2" }; + case "terminal.close": + return { closed: "t:2" }; + case "workspace.close": + return { closed: "ws:2", killed: false, tabline: "" }; + case "terminal.send": + return { sent_to: "t:42", bytes: 2 }; + case "config.reload": + return { + probed: true, + applied: false, + path: "(defaults; no file)", + hot_swap: "follow-up", + }; + default: + throw new Error(`missing success projection for ${verb}`); + } +} + +function controlInterleavedAuthorizationCases(marker: string): string[] { + const controls = ["\u001b", "\u009b"]; + const cases = new Set(); + const insert = (value: string, control: string, index: number): string => + `${value.slice(0, index)}${control}${value.slice(index)}`; + + for (const authorizationControl of controls) { + for ( + let authorizationIndex = 0; + authorizationIndex <= "Authorization".length; + authorizationIndex += 1 + ) { + const authorization = insert( + "Authorization", + authorizationControl, + authorizationIndex, + ); + for (const bearerControl of controls) { + for ( + let bearerIndex = 0; + bearerIndex <= "Bearer".length; + bearerIndex += 1 + ) { + const bearer = insert("Bearer", bearerControl, bearerIndex); + cases.add(`${authorization}: ${bearer} ${marker}`); + } + } + } + } + + for (const valueControl of controls) { + for (let markerIndex = 0; markerIndex <= marker.length; markerIndex += 1) { + const value = insert(marker, valueControl, markerIndex); + cases.add(`Authorization: Bearer ${value}`); + } + } + + for (const authorizationControl of controls) { + for (const bearerControl of controls) { + for (const valueControl of controls) { + cases.add( + `${insert("Authorization", authorizationControl, 6)}: ${insert("Bearer", bearerControl, 3)} ${insert(marker, valueControl, 10)}`, + ); + } + } + } + return [...cases]; +} + +function allControlUnexpectedFieldNames(marker: string): string[] { + const controls = [ + ...Array.from({ length: 0x20 }, (_, code) => String.fromCharCode(code)), + String.fromCharCode(0x7f), + ...Array.from({ length: 0x20 }, (_, index) => + String.fromCharCode(0x80 + index), + ), + ]; + const cases = new Set(); + const insert = (value: string, control: string, index: number): string => + `${value.slice(0, index)}${control}${value.slice(index)}`; + + for (const control of controls) { + for (let index = 0; index <= "Authorization".length; index += 1) { + const authorization = insert("Authorization", control, index); + cases.add(`${authorization}: Bearer ${marker}`); + cases.add(`Proxy-${authorization}: Bearer ${marker}`); + } + for (let index = 0; index <= "Bearer".length; index += 1) { + cases.add(`Authorization: ${insert("Bearer", control, index)} ${marker}`); + } + for (let index = 0; index <= marker.length; index += 1) { + cases.add(`Authorization: Bearer ${insert(marker, control, index)}`); + } + } + for (const authorizationControl of controls) { + for (const bearerControl of controls) { + cases.add( + `${insert("Authorization", authorizationControl, 6)}: ${insert("Bearer", bearerControl, 3)} ${marker}`, + ); + } + } + return [...cases]; +} + +const UNICODE_FORMAT_SEPARATORS = [ + "\u00a0", + "\u00ad", + "\u034f", + "\u061c", + "\u115f", + "\u1160", + "\u180e", + "\u200b", + "\u200c", + "\u200d", + "\u200e", + "\u200f", + "\u2028", + "\u202a", + "\u202b", + "\u202c", + "\u202d", + "\u202e", + "\u202f", + "\u2060", + "\u2066", + "\u2067", + "\u2068", + "\u2069", + "\u3000", + "\u3164", + "\ufe0f", + "\ufeff", + "\uffa0", + "\u{e0001}", + "\u{e0100}", +] as const; + +function formatSeparatorCredentialFields(marker: string): string[] { + const cases = new Set([ + `Authorization: Bearer ${marker}`, + `Proxy-Authorization: Bearer ${marker}`, + `Bearer ${marker}`, + `api_key: ${marker}`, + ]); + const insert = (value: string, separator: string, index: number): string => + `${value.slice(0, index)}${separator}${value.slice(index)}`; + + for (const separator of UNICODE_FORMAT_SEPARATORS) { + for (let index = 0; index <= "Authorization".length; index += 1) { + const authorization = insert("Authorization", separator, index); + cases.add(`${authorization}: Bearer ${marker}`); + cases.add(`Proxy-${authorization}: Bearer ${marker}`); + } + for (let index = 0; index <= "Bearer".length; index += 1) { + cases.add( + `Authorization: ${insert("Bearer", separator, index)} ${marker}`, + ); + } + for (let index = 0; index <= marker.length; index += 1) { + cases.add(`Authorization: Bearer ${insert(marker, separator, index)}`); + } + cases.add(`api${separator}key: ${marker}`); + cases.add( + `${insert("Authorization", separator, 6)}: ${insert("Bearer", separator, 3)} ${insert(marker, separator, 10)}`, + ); + } + return [...cases]; +} + function specialResult(invocation: CtlInvocation): CtlResult | undefined { switch (invocation.verb) { case "workspace.list.baseline": - return makeOkResult("core.workspace.list", { - workspaces: ["ws1"], - active: 1, - count: 1, - }); + return makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1"], 1), + ); case "workspace.new": - return makeOkResult("core.workspace.new", { created: "ws:2" }); - case "workspace.list.after-new": - return makeOkResult("core.workspace.list", { - workspaces: ["ws1", "ws:2"], - active: 2, - count: 2, + return makeOkResult("core.workspace.new", { + created: "ws:2", + tabline: "", }); + case "workspace.list.after-new": + return makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1", "ws:2"], 2), + ); case "workspace.focus": - return makeOkResult("core.workspace.focus", { focused: "ws:2" }); + return makeOkResult("core.workspace.focus", { + focused: invocation.args[2] ?? "ws:2", + tabline: "", + }); case "terminal.text": return makeOkResult("core.terminal.text", { terminal_id: "t:1", @@ -95,8 +314,8 @@ function specialResult(invocation: CtlInvocation): CtlResult | undefined { case "view.list.after": return makeOkResult("core.view.list", { views: [ - { id: "v:1", focused: true }, - { id: "v:2", focused: false }, + { id: "v:1", focused: false }, + { id: "v:2", focused: true }, ], }); case "terminal.list.after": @@ -116,17 +335,18 @@ function resultFor(invocation: CtlInvocation): CtlResult { if (special !== undefined) return special; const command = `core.${invocation.verb}`; const expectation = CTL_VERB_MATRIX.find((v) => v.verb === invocation.verb); + if (invocation.verb === "terminal.spawn" && invocation.elevated) { + return makeOkResult(command, { + spawned: true, + terminal_id: "t:2", + view_id: "v:2", + }); + } if (expectation !== undefined) { - if (invocation.elevated && expectation.outcome === "denied") { - return makeOkResult(command, { - spawned: true, - closed: true, - reloaded: true, - }); + if (invocation.elevated || expectation.outcome === "ok") { + return makeOkResult(command, successResultFor(invocation.verb)); } switch (expectation.outcome) { - case "ok": - return makeOkResult(command, { ok: true }); case "denied": return makeErrorResult(command, DENIED, EXIT_PERM); case "conflict": @@ -244,6 +464,22 @@ describe("campaign envelope conformance (v1 shape + exit codes)", () => { expect(results[0]?.status).toBe("pass"); }); + test("error class and code must both match", async () => { + const dispatcher = campaignDispatcher({ + "terminal.spawn": makeErrorResult( + "core.terminal.spawn", + { class: "Denied", code: "SyntheticWrongCode", message: "synthetic" }, + EXIT_PERM, + ), + }); + const results = await probeEnvelopeConformance(dispatcher); + const spawn = results.find( + (result) => result.name === "envelope:terminal.spawn", + ); + expect(spawn?.status).toBe("fail"); + expect(spawn?.detail).toBe("error class/code did not match expectation"); + }); + test("wrong exit code is a conformance failure", async () => { const dispatcher = campaignDispatcher({ "terminal.spawn": makeErrorResult("core.terminal.spawn", DENIED, EXIT_OK), @@ -288,27 +524,30 @@ describe("workspace id round-trip guard (D2)", () => { const dispatcher = new ScriptedCtlDispatcher((inv) => { seen.push(inv); if (inv.verb === "workspace.list.baseline") { - return makeOkResult("core.workspace.list", { - workspaces: ["ws1"], - active: 1, - count: 1, - }); + return makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1"], 1), + ); } if (inv.verb === "workspace.new") { - return makeOkResult("core.workspace.new", { created: "ws:2" }); + return makeOkResult("core.workspace.new", { + created: "ws:2", + tabline: "", + }); } if (inv.verb === "workspace.list.after-new") { - return makeOkResult("core.workspace.list", { - workspaces: ["--socket=/tmp/evil.sock"], - active: 1, - count: 1, - }); + return makeOkResult( + "core.workspace.list", + workspaceListResult(["--socket=/tmp/evil.sock"], 1), + ); } throw new Error(`unexpected dispatch ${inv.verb}`); }); const result = await probeWorkspaceIdRoundTrip(dispatcher); expect(result.status).toBe("fail"); - expect(result.detail).toContain("is not a workspace id"); + expect(result.detail).toContain( + "workspace post-create projection is invalid", + ); expect(seen.some((inv) => inv.verb === "workspace.focus")).toBe(false); }); @@ -318,27 +557,30 @@ describe("workspace id round-trip guard (D2)", () => { const dispatcher = new ScriptedCtlDispatcher((inv) => { seen.push(inv); if (inv.verb === "workspace.list.baseline") { - return makeOkResult("core.workspace.list", { - workspaces: ["ws1"], - active: 1, - count: 1, - }); + return makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1"], 1), + ); } if (inv.verb === "workspace.new") { - return makeOkResult("core.workspace.new", { created: "ws:2" }); + return makeOkResult("core.workspace.new", { + created: "ws:2", + tabline: "", + }); } if (inv.verb === "workspace.list.after-new") { - return makeOkResult("core.workspace.list", { - workspaces: [hostile], - active: 1, - count: 1, - }); + return makeOkResult( + "core.workspace.list", + workspaceListResult([hostile], 1), + ); } throw new Error(`unexpected dispatch ${inv.verb}`); }); const result = await probeWorkspaceIdRoundTrip(dispatcher); expect(result.status).toBe("fail"); - expect(result.detail).toContain("is not a workspace id"); + expect(result.detail).toContain( + "workspace post-create projection is invalid", + ); expect(seen.some((inv) => inv.verb === "workspace.focus")).toBe(false); } }); @@ -365,11 +607,10 @@ describe("workspace id round-trip guard (D2)", () => { test("fails when a listed id is rejected by focus (D2 repro)", async () => { const dispatcher = campaignDispatcher({ - "workspace.list.after-new": makeOkResult("core.workspace.list", { - workspaces: ["ws1", "ws4"], - active: 2, - count: 2, - }), + "workspace.list.after-new": makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1", "ws4"], 2), + ), "workspace.focus": makeErrorResult( "core.workspace.focus", NOTFOUND, @@ -378,7 +619,7 @@ describe("workspace id round-trip guard (D2)", () => { }); const result = await probeWorkspaceIdRoundTrip(dispatcher); expect(result.status).toBe("fail"); - expect(result.detail).toContain("rejected by focus"); + expect(result.detail).toContain("was rejected"); }); test("created id must be a ws: id", () => { @@ -387,7 +628,7 @@ describe("workspace id round-trip guard (D2)", () => { v: 1, command: "core.workspace.new", ok: true, - result: { created: "ws2" }, + result: { created: "ws2", tabline: "" }, }), ); expect(workspaceCreatedFrom(bad)).toBe("ws2"); @@ -396,7 +637,7 @@ describe("workspace id round-trip guard (D2)", () => { v: 1, command: "core.workspace.list", ok: true, - result: { workspaces: ["ws1"] }, + result: workspaceListResult(["ws1"], 1), }), ); expect(workspaceNamesFrom(names)).toEqual(["ws1"]); @@ -429,16 +670,17 @@ describe("terminal text shape guard (D1)", () => { expect(result.detail).toContain("Debug dump"); }); - test("terminalTextFrom requires a string", () => { - const envelope = parseCtlEnvelope( - JSON.stringify({ - v: 1, - command: "core.terminal.text", - ok: true, - result: {}, - }), - ); - expect(() => terminalTextFrom(envelope)).toThrow(CampaignError); + test("terminal text projection requires a string", () => { + expect(() => + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command: "core.terminal.text", + ok: true, + result: {}, + }), + ), + ).toThrow(CampaignError); }); }); @@ -448,13 +690,19 @@ describe("terminal spawn observability guard (D3)", () => { expect(result.status).toBe("pass"); }); - test("passes when only has_pane_session flips", async () => { + test("passes when the created terminal owns the flipped pane session", async () => { const dispatcher = campaignDispatcher({ "view.list.after": makeOkResult("core.view.list", { - views: [{ id: "v:1", focused: true }], + views: [ + { id: "v:1", focused: false }, + { id: "v:2", focused: true }, + ], }), "terminal.list.after": makeOkResult("core.terminal.list", { - terminals: [{ id: "t:1", has_pane_session: true }], + terminals: [ + { id: "t:1", has_pane_session: true }, + { id: "t:2", has_pane_session: true }, + ], }), }); const result = await probeTerminalSpawnObservability(dispatcher); @@ -472,7 +720,7 @@ describe("terminal spawn observability guard (D3)", () => { }); const result = await probeTerminalSpawnObservability(dispatcher); expect(result.status).toBe("fail"); - expect(result.detail).toContain("no view/terminal"); + expect(result.detail).toContain("was not observable"); }); }); @@ -569,8 +817,8 @@ describe("durable dispatcher seam", () => { baseArgs: ["ctl"], }); await dispatcher.dispatch({ - verb: "view.list", - args: ["view", "list"], + verb: "terminal.spawn", + args: ["terminal", "spawn"], elevated: true, }); expect(calls[0]?.program).toBe("bitty"); @@ -578,14 +826,14 @@ describe("durable dispatcher seam", () => { "ctl", "--socket", "/run/bitty/default.sock", - "view", - "list", + "terminal", + "spawn", ]); - expect(calls[0]?.env["BITTY_CTL_ELEVATE"]).toBe(DEFAULT_ELEVATION_SCOPES); + expect(calls[0]?.env["BITTY_CTL_ELEVATE"]).toBe("terminal.manage"); await dispatcher.dispatch({ - verb: "view.list", - args: ["view", "list"], + verb: "terminal.spawn", + args: ["terminal", "spawn"], elevated: false, }); expect(calls[1]?.env["BITTY_CTL_ELEVATE"]).toBeUndefined(); @@ -599,7 +847,7 @@ describe("durable dispatcher seam", () => { elevated: true, }); const announced = calls[0]?.env["BITTY_CTL_ELEVATE"]; - expect(announced).toBe("terminal.manage,config.modify"); + expect(announced).toBe("terminal.manage"); expect(announced).not.toBe("1"); expect(announced?.split(",")).toContain("terminal.manage"); }); @@ -732,7 +980,7 @@ describe("campaign admission and ownership", () => { expect(report.ok).toBe(false); expect( report.results.find((r) => r.name === "campaign:admission")?.detail, - ).toBe(String(thrown)); + ).toBe("campaign operation failed"); expect(dispatcher.seen()).toEqual([]); }); test(`preflight reports thrown ${String(thrown)} without dispatch`, async () => { @@ -748,7 +996,7 @@ describe("campaign admission and ownership", () => { }, }); expect(report.ok).toBe(false); - expect(report.results[0]?.detail).toContain(String(thrown)); + expect(report.results[0]?.detail).toBe("campaign operation failed"); expect(dispatcher.seen()).toEqual([]); }); @@ -766,7 +1014,7 @@ describe("campaign admission and ownership", () => { }); expect(result.status).toBe("fail"); expect(result.detail).toBe( - `${String(thrown)}; owned workspace cleanup failed: ${String(thrown)}`, + "campaign operation failed; owned workspace cleanup failed: campaign operation failed", ); expect( dispatcher @@ -820,7 +1068,7 @@ describe("campaign admission and ownership", () => { elevated: true, }); expect(result.status).toBe("fail"); - expect(result.detail).toContain("rejected by close"); + expect(result.detail).toContain("cleanup response did not match"); expect( dispatcher .seen() @@ -918,37 +1166,47 @@ describe("campaign admission and ownership", () => { expect( dispatcher .seen() - .filter((inv) => inv.args[1] === "close") + .filter((inv) => inv.verb === "workspace.close") .map((inv) => inv.args[2]), ).toEqual(["ws:2"]); }); - test("cleanup closes only the created workspace, not newly listed or baseline IDs", async () => { + test("workspace cleanup is complete and idempotent across listed new ids", async () => { const dispatcher = campaignDispatcher({ - "workspace.list.after-new": makeOkResult("core.workspace.list", { - workspaces: ["ws1", "ws2", "ws:3", "ws:2"], - }), + "workspace.list.after-new": makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1", "ws2", "ws:3", "ws:2"], 3), + ), + }); + const result = await probeWorkspaceIdRoundTrip(dispatcher, { + elevated: true, }); - await probeWorkspaceIdRoundTrip(dispatcher, { elevated: true }); + expect(result.status).toBe("fail"); expect( dispatcher .seen() .filter((inv) => inv.verb === "workspace.close") .map((inv) => inv.args[2]), - ).toEqual(["ws:2"]); + ).toEqual(["ws:2", "ws:3"]); }); test("a created ID already present under a baseline alias is never closed", async () => { const dispatcher = campaignDispatcher({ - "workspace.new": makeOkResult("core.workspace.new", { created: "ws:01" }), + "workspace.new": makeOkResult("core.workspace.new", { + created: "ws:01", + tabline: "", + }), }); const result = await probeWorkspaceIdRoundTrip(dispatcher, { elevated: true, }); expect(result.status).toBe("fail"); expect( - dispatcher.seen().some((inv) => inv.verb === "workspace.close"), - ).toBe(false); + dispatcher + .seen() + .filter((inv) => inv.verb === "workspace.close") + .map((inv) => inv.args[2]), + ).toEqual(["ws:2"]); }); test("owned cleanup runs after a later observation failure", async () => { @@ -1065,7 +1323,10 @@ describe("keystroke-injection probe gating (H-DEV-04)", () => { let dispatched = 0; const dispatcher = new ScriptedCtlDispatcher(() => { dispatched += 1; - return makeOkResult("core.terminal.send", { ok: true }); + return makeOkResult("core.terminal.send", { + sent_to: "t:42", + bytes: 2, + }); }); const results = await probeEnvelopeConformance(dispatcher, [ { @@ -1093,7 +1354,10 @@ describe("keystroke-injection probe gating (H-DEV-04)", () => { let dispatched = 0; const dispatcher = new ScriptedCtlDispatcher(() => { dispatched += 1; - return makeOkResult("core.terminal.send", { ok: true }); + return makeOkResult("core.terminal.send", { + sent_to: "t:42", + bytes: 2, + }); }); const results = await probeEnvelopeConformance(dispatcher, [ { @@ -1112,7 +1376,7 @@ describe("keystroke-injection probe gating (H-DEV-04)", () => { const seen: string[] = []; const dispatcher = new ScriptedCtlDispatcher((inv) => { seen.push(inv.verb); - return makeOkResult(`core.${inv.verb}`, { ok: true }); + return makeOkResult(`core.${inv.verb}`, successResultFor(inv.verb)); }); await runCampaign({ dispatcher }); expect(seen).not.toContain(KEYSTROKE_PROBE_VERB); @@ -1151,7 +1415,7 @@ describe("keystroke-injection probe gating (H-DEV-04)", () => { const dispatcher = attestFixtureDispatcher( new ScriptedCtlDispatcher((inv) => { seen.push(inv.args); - return makeOkResult(`core.${inv.verb}`, { ok: true }); + return makeOkResult(`core.${inv.verb}`, successResultFor(inv.verb)); }), ); await runCampaign({ @@ -1164,3 +1428,1243 @@ describe("keystroke-injection probe gating (H-DEV-04)", () => { expect(sends[0]).toContain("t:42"); }); }); + +describe("campaign child environment and producer bounds", () => { + const syntheticSecret = "SYNTHETIC_AMBIENT_SECRET_DO_NOT_PERSIST"; + + test("low-level spawn helper is private and combined elevation is rejected", () => { + expect(campaignModule).not.toHaveProperty("defaultSpawnSync"); + expect(() => + buildCampaignChildEnvironment( + {}, + { BITTY_CTL_ELEVATE: "terminal.manage,config.modify" }, + ), + ).toThrow(CampaignError); + }); + + test("child environment is rebuilt from an explicit allowlist", () => { + const env = buildCampaignChildEnvironment( + { + PATH: "/synthetic/bin", + XDG_RUNTIME_DIR: "/synthetic/runtime", + BITTY_CTL_ELEVATE: "config.modify", + SSH_AUTH_SOCK: "/synthetic/agent", + [syntheticSecret]: syntheticSecret, + }, + { + BITTY_CTL_ELEVATE: undefined, + XDG_RUNTIME_DIR: "/synthetic/explicit-runtime", + ANOTHER_SYNTHETIC_SECRET: syntheticSecret, + }, + ); + + expect(env["PATH"]).toBe("/synthetic/bin"); + expect(env["XDG_RUNTIME_DIR"]).toBe("/synthetic/explicit-runtime"); + expect(env["BITTY_CTL_ELEVATE"]).toBeUndefined(); + expect(env["SSH_AUTH_SOCK"]).toBeUndefined(); + expect(env[syntheticSecret]).toBeUndefined(); + expect(env["ANOTHER_SYNTHETIC_SECRET"]).toBeUndefined(); + expect( + Object.keys(env).every((key) => + [...CAMPAIGN_CHILD_ENV_ALLOWLIST, "BITTY_CTL_ELEVATE"].includes(key), + ), + ).toBe(true); + }); + + test("fake spawn receives maxBuffer and no ambient marker", async () => { + type FakeSpawnOptions = { + cmd: string[]; + env?: Record; + maxBuffer?: number; + }; + type FakeSpawnResult = { + exitCode: number | null; + stdout: { byteLength: number; toString(): string }; + stderr: { byteLength: number; toString(): string }; + signalCode: null; + }; + const runtime = globalThis as unknown as { + Bun: { + spawnSync(options: FakeSpawnOptions): FakeSpawnResult; + }; + }; + const original = runtime.Bun.spawnSync; + let seen: FakeSpawnOptions | undefined; + runtime.Bun.spawnSync = (options) => { + seen = options; + const stdout = JSON.stringify({ + v: 1, + command: "core.view.list", + ok: true, + result: { views: [] }, + }); + return { + exitCode: 0, + stdout: { + byteLength: new TextEncoder().encode(stdout).length, + toString: () => stdout, + }, + stderr: { byteLength: 0, toString: () => "" }, + signalCode: null, + }; + }; + + try { + const dispatcher = new ProcessCtlDispatcher({ + env: { [syntheticSecret]: syntheticSecret }, + }); + const result = await dispatcher.dispatch({ + verb: "view.list", + args: ["view", "list"], + elevated: false, + }); + expect(result.exitCode).toBe(EXIT_OK); + expect(seen?.maxBuffer).toBe(MAX_CAMPAIGN_OUTPUT_BYTES); + expect(seen?.env?.[syntheticSecret]).toBeUndefined(); + } finally { + runtime.Bun.spawnSync = original; + } + }); + + test("oversized producer output is rejected without string materialization", async () => { + type FakeSpawnResult = { + exitCode: number; + stdout: { byteLength: number; toString(): string }; + stderr: { byteLength: number; toString(): string }; + }; + const runtime = globalThis as unknown as { + Bun: { + spawnSync(options: unknown): FakeSpawnResult; + }; + }; + const original = runtime.Bun.spawnSync; + let materialized = false; + runtime.Bun.spawnSync = () => ({ + exitCode: 0, + stdout: { + byteLength: MAX_CAMPAIGN_OUTPUT_BYTES + 1, + toString: () => { + materialized = true; + return "synthetic"; + }, + }, + stderr: { byteLength: 0, toString: () => "" }, + }); + + try { + const dispatcher = new ProcessCtlDispatcher(); + await expect( + dispatcher.dispatch({ + verb: "view.list", + args: ["view", "list"], + elevated: false, + }), + ).rejects.toThrow("exceeds"); + expect(materialized).toBe(false); + } finally { + runtime.Bun.spawnSync = original; + } + }); +}); + +describe("campaign envelope and observation bounds", () => { + test("requires exactly one closed envelope branch", () => { + const success = { + v: 1, + command: "core.view.list", + ok: true, + result: { views: [] }, + }; + expect(() => parseCtlEnvelope(`${JSON.stringify(success)}\n{}\n`)).toThrow( + CampaignError, + ); + expect( + validateEnvelopeShape({ ...success, extra: true }).some((problem) => + problem.includes("unexpected field"), + ), + ).toBe(true); + expect( + validateEnvelopeShape({ ...success, error: DENIED }).some((problem) => + problem.includes("exclusive"), + ), + ).toBe(true); + expect( + validateEnvelopeShape({ + v: 1, + command: "core.view.list", + ok: false, + }).some((problem) => problem.includes("exclusive")), + ).toBe(true); + }); + + test("rejects oversized bytes, arrays, strings, and nesting before use", () => { + expect(() => + parseCtlEnvelope("x".repeat(MAX_CAMPAIGN_OUTPUT_BYTES + 1)), + ).toThrow(CampaignError); + expect(() => + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command: "core.workspace.list", + ok: true, + result: { + workspaces: Array(MAX_CAMPAIGN_ARRAY_ITEMS + 1).fill("ws:1"), + }, + }), + ), + ).toThrow(CampaignError); + expect(() => + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command: "c".repeat(2048), + ok: true, + result: {}, + }), + ), + ).toThrow(CampaignError); + + let nested: unknown = "synthetic"; + for (let index = 0; index < 32; index += 1) nested = [nested]; + expect(() => + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command: "core.view.list", + ok: true, + result: nested, + }), + ), + ).toThrow(CampaignError); + }); + + test("mixed workspace arrays fail before create, focus, or cleanup", async () => { + const dispatcher = new ScriptedCtlDispatcher((invocation) => { + if (invocation.verb === "workspace.list.baseline") { + return makeOkResult("core.workspace.list", { + workspaces: ["ws:1", 7], + }); + } + throw new Error(`unexpected dispatch ${invocation.verb}`); + }); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("fail"); + expect(dispatcher.seen().map((invocation) => invocation.verb)).toEqual([ + "workspace.list.baseline", + ]); + }); + + test("malformed view and terminal arrays fail before spawn", async () => { + for (const overrides of [ + { + "view.list.before": makeOkResult("core.view.list", { + views: [{ focused: true }], + }), + }, + { + "terminal.list.before": makeOkResult("core.terminal.list", { + terminals: [{ id: "t:1" }], + }), + }, + { + "view.list.before": makeOkResult("core.view.list", { + views: [ + { id: "v:1", focused: true }, + { id: "v:1", focused: false }, + ], + }), + }, + { + "terminal.list.before": makeOkResult("core.terminal.list", { + terminals: [ + { id: "t:1", has_pane_session: false }, + { id: "t:1", has_pane_session: false }, + ], + }), + }, + { + "terminal.list.before": makeOkResult("core.terminal.list", { + terminals: [ + { id: "t:1", has_pane_session: false }, + { id: "t:2", has_pane_session: false }, + ], + }), + }, + ]) { + const dispatcher = campaignDispatcher(overrides); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .some((invocation) => invocation.verb === "terminal.spawn"), + ).toBe(false); + } + }); + + test("matrix cardinality is bounded before any dispatch", async () => { + const dispatcher = new ScriptedCtlDispatcher(() => + makeOkResult("core.oversized", { ok: true }), + ); + const matrix = Array.from( + { length: MAX_CAMPAIGN_MATRIX_ROWS + 1 }, + (_, index) => ({ + verb: `oversized.${index}`, + args: ["oversized"], + outcome: "ok" as const, + elevated: false, + note: "synthetic", + }), + ); + const results = await probeEnvelopeConformance(dispatcher, matrix); + expect(results).toHaveLength(1); + expect(results[0]?.status).toBe("fail"); + expect(dispatcher.seen()).toEqual([]); + }); + + test("runCampaign rejects oversized matrices before reading or filtering rows", async () => { + let argsReads = 0; + const matrix = Array.from({ length: 1000 }, () => ({ + verb: "view.list", + get args(): string[] { + argsReads += 1; + return ["view", "list", "--format", "json"]; + }, + outcome: "ok" as const, + elevated: false, + note: "synthetic", + })); + const report = await runCampaign({ + ...admittedCampaign, + dispatcher: campaignDispatcher(), + matrix, + }); + expect(argsReads).toBe(0); + expect(report.results).toHaveLength(1); + expect(report.results[0]).toMatchObject({ + name: "campaign:matrix-limit", + status: "fail", + }); + }); + + test("malformed matrix rows fail closed without property dereferences", async () => { + const dispatcher = new ScriptedCtlDispatcher(() => + makeOkResult("core.invalid", {}), + ); + const results = await probeEnvelopeConformance(dispatcher, [null] as never); + expect(results).toHaveLength(1); + expect(results[0]?.status).toBe("fail"); + expect(dispatcher.seen()).toEqual([]); + }); + + test("null matrices fail closed in probe and campaign entry points", async () => { + const dispatcher = campaignDispatcher(); + const probeResults = await probeEnvelopeConformance( + dispatcher, + null as never, + ); + expect(probeResults).toHaveLength(1); + expect(probeResults[0]?.status).toBe("fail"); + + const report = await runCampaign({ + ...admittedCampaign, + dispatcher, + matrix: null as never, + }); + expect(report.results).toHaveLength(1); + expect(report.results[0]).toMatchObject({ + name: "campaign:matrix-invalid", + status: "fail", + }); + expect(dispatcher.seen()).toEqual([]); + }); + + test("invalid matrix values fail before filtering or dispatch", async () => { + const valid = { + verb: "view.list", + args: ["view", "list", "--format", "json"], + outcome: "ok" as const, + elevated: false, + note: "synthetic", + }; + for (const invalid of [ + { ...valid, outcome: null }, + { ...valid, args: [null] }, + { ...valid, note: null }, + { ...valid, elevated: null }, + ]) { + const dispatcher = campaignDispatcher(); + const report = await runCampaign({ + ...admittedCampaign, + dispatcher, + matrix: [invalid] as never, + }); + expect(report.ok).toBe(false); + expect(report.results[0]?.name).toBe("campaign:matrix-invalid"); + expect(dispatcher.seen()).toEqual([]); + } + }); + + test("per-verb result projections reject unknown success fields", async () => { + expect(() => + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command: "core.instance.list", + ok: true, + result: { unexpected: true }, + }), + ), + ).toThrow(CampaignError); + const dispatcher = new ScriptedCtlDispatcher(() => + makeOkResult("core.instance.list", { + unexpected: "\u001b[31m", + }), + ); + const results = await probeEnvelopeConformance(dispatcher, [ + { + verb: "instance.list", + args: ["instance", "list", "--format", "json"], + outcome: "ok", + elevated: false, + note: "synthetic", + }, + ]); + expect(results[0]?.status).toBe("fail"); + expect(results[0]?.detail).toContain("projection"); + }); + + test("ctl envelopes reject duplicate keys before interpretation", () => { + expect(() => + parseCtlEnvelope( + '{"v":1,"command":"core.instance.list","ok":true,"result":{"instances":[]},"result":{"unexpected":true}}', + ), + ).toThrow(CampaignError); + expect(() => + parseCtlEnvelope( + '{"v":1,"command":"core.instance.list","ok":true,"result":{"outer":{"value":1,"value":2}}}', + ), + ).toThrow(CampaignError); + }); + test("ctl validation and parser diagnostics redact every typed control matrix", () => { + const marker = "SYNTHETIC_OPAQUE_123456"; + const diagnostics: string[] = []; + for (const field of allControlUnexpectedFieldNames(marker)) { + const value = { + v: 1, + command: "core.view.list", + ok: true, + result: {}, + [field]: true, + }; + diagnostics.push(...validateEnvelopeShape(value)); + try { + parseCtlEnvelope(JSON.stringify(value)); + } catch (error) { + diagnostics.push((error as Error).message); + } + } + let errorPayloads = 0; + let rejectedErrorPayloads = 0; + for (const field of [ + ...allControlUnexpectedFieldNames(marker), + `Authorization: Bearer ${marker}`, + `Proxy-Authorization: Bearer ${marker}`, + `Bearer ${marker}`, + ]) { + for (const carrier of ["class", "code", "message"] as const) { + errorPayloads += 1; + const value = { + v: 1, + command: "core.terminal.spawn", + ok: false, + error: { + class: "Denied", + code: "ScopeDenied", + message: "synthetic", + [carrier]: field, + }, + }; + diagnostics.push(...validateEnvelopeShape(value)); + try { + parseCtlEnvelope(JSON.stringify(value)); + } catch (error) { + rejectedErrorPayloads += 1; + diagnostics.push((error as Error).message); + } + } + } + expect(rejectedErrorPayloads).toBe(errorPayloads); + for (const command of [ + `core.Authorization: Bearer ${marker}`, + `core.Proxy-Authorization: Bearer ${marker}`, + `core.Bearer ${marker}`, + ]) { + try { + parseCtlEnvelope( + JSON.stringify({ + v: 1, + command, + ok: true, + result: {}, + }), + ); + } catch (error) { + diagnostics.push((error as Error).message); + } + } + const serialized = diagnostics.join(""); + expect(serialized).not.toContain(marker); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(serialized)).toBe(false); + }); + test("ctl diagnostics reject unicode-interleaved typed fields", () => { + const marker = "SYNTHETIC_OPAQUE_123456"; + const diagnostics: string[] = []; + let rejected = 0; + for (const field of formatSeparatorCredentialFields(marker)) { + const values: unknown[] = [ + { + v: 1, + command: "core.view.list", + ok: true, + result: {}, + [field]: true, + }, + ...["class", "code", "message"].map((carrier) => ({ + v: 1, + command: "core.terminal.spawn", + ok: false, + error: { + class: "Denied", + code: "ScopeDenied", + message: "synthetic", + [carrier]: field, + }, + })), + ]; + for (const value of values) { + diagnostics.push(...validateEnvelopeShape(value)); + try { + parseCtlEnvelope(JSON.stringify(value)); + } catch (error) { + rejected += 1; + diagnostics.push((error as Error).message); + } + } + } + expect(rejected).toBe(formatSeparatorCredentialFields(marker).length * 4); + const serialized = diagnostics.join(""); + expect(serialized).not.toContain(marker); + for (const separator of UNICODE_FORMAT_SEPARATORS) { + expect(serialized).not.toContain(separator); + } + }); +}); + +describe("campaign report privacy and control safety", () => { + const syntheticSecret = "SYNTHETIC_SECRET_DO_NOT_PERSIST"; + + test("terminal output sanitizer escapes C0, DEL, and C1 bytes", () => { + const sanitized = sanitizeTerminalOutput( + `safe\u0000\u001b[31m\u007f\u0085\u009b${syntheticSecret}\n`, + 1024, + ); + expect(sanitized).toContain("\\u0000"); + expect(sanitized).toContain("\\u001b"); + expect(sanitized).toContain("\\u007f"); + expect(sanitized).toContain("\\u0085"); + expect(sanitized).toContain("\\u009b"); + expect(sanitized).toContain("\\n"); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(sanitized)).toBe(false); + expect(new TextEncoder().encode(sanitized).length).toBeLessThanOrEqual( + 1024, + ); + }); + + test("unicode format separators are removed before redaction and reporting", () => { + const marker = "SYNTHETIC_OPAQUE_123456"; + for (const separator of UNICODE_FORMAT_SEPARATORS) { + expect(sanitizeTerminalOutput(`a${separator}b`, 128)).toBe("ab"); + } + const redacted = + formatSeparatorCredentialFields(marker).map(redactSensitiveText); + const report = summarizeCampaign( + redacted.map((detail) => ({ + name: "unicode-format", + status: "fail" as const, + detail, + evidence: [`Proxy-${detail}`], + })), + ); + const serialized = JSON.stringify(report); + expect(serialized).not.toContain(marker); + for (const separator of UNICODE_FORMAT_SEPARATORS) { + expect(serialized).not.toContain(separator); + } + }); + + test("shared differential corpus redacts in TypeScript", async () => { + const corpus = await Bun.file( + "tests/fixtures/redaction-separator-corpus.txt", + ).text(); + let cases = 0; + for (const line of corpus.split("\n")) { + if (line.length === 0 || line.startsWith("#")) continue; + const [id, hex, expected] = line.split("\t"); + if (id === undefined || hex === undefined || expected === undefined) { + throw new Error(`invalid corpus row: ${line}`); + } + const bytes = Uint8Array.from( + (hex.match(/.{2}/gu) ?? []).map((byte) => Number.parseInt(byte, 16)), + ); + const input = new TextDecoder().decode(bytes); + const actual = redactSensitiveText(input); + const wanted = expected === "true" ? "[REDACTED]" : input; + expect(actual, id).toBe(wanted); + cases += 1; + } + // Exact count, not a floor: a silently dropped fixture must fail here as + // loudly as a wrong expectation, and the Rust suite asserts the same total. + expect(cases).toBe(2298); + }); + + test("NORM-1 normalization class matches the shared membership pin", async () => { + const pin = await Bun.file( + "tests/fixtures/redaction-normalization-class.txt", + ).text(); + let members = 0; + let nonMembers = 0; + for (const line of pin.split("\n")) { + if (line.length === 0 || line.startsWith("#")) continue; + const [kind, hex] = line.split("\t"); + if (kind === undefined || hex === undefined) { + throw new Error(`invalid class pin row: ${line}`); + } + const codePoint = Number.parseInt(hex, 16); + const label = `U+${hex}`; + expect(isNormalizationSeparator(codePoint), `${label} ${kind}`).toBe( + kind === "member", + ); + if (kind === "member") members += 1; + else nonMembers += 1; + } + expect(members).toBe(4225); + expect(nonMembers).toBe(266); + }); + + test("NORM-1 class property definition matches the shared membership pin", async () => { + // The pin is the contract; the predicate is the implementation. Deriving + // the class a second time from the three Unicode properties and comparing + // it to the pin catches a pinned row that no longer follows from the + // definition, which the membership test above cannot see. + const pin = await Bun.file( + "tests/fixtures/redaction-normalization-class.txt", + ).text(); + const pinned = new Set(); + for (const line of pin.split("\n")) { + if (!line.startsWith("member\t")) continue; + pinned.add(Number.parseInt(line.split("\t")[1] as string, 16)); + } + const defaultIgnorable = /\p{Default_Ignorable_Code_Point}/u; + const otherFormat = /\p{Cf}/u; + const whiteSpace = /\p{White_Space}/u; + const derived = new Set(); + for (let codePoint = 0; codePoint <= 0x10ffff; codePoint += 1) { + if (codePoint >= 0xd800 && codePoint <= 0xdfff) continue; + const character = String.fromCodePoint(codePoint); + if ( + codePoint > 0x7f && + (defaultIgnorable.test(character) || + otherFormat.test(character) || + whiteSpace.test(character)) + ) { + derived.add(codePoint); + } + } + const missing = [...derived].filter((codePoint) => !pinned.has(codePoint)); + const extra = [...pinned].filter((codePoint) => !derived.has(codePoint)); + expect( + { missing: missing.length, extra: extra.length }, + `missing U+${missing[0]?.toString(16)} extra U+${extra[0]?.toString(16)}`, + ).toEqual({ missing: 0, extra: 0 }); + }); + + test("P1 regression: a capitalized or upper-case key is redacted", () => { + const marker = "SYNTHETIC_OPAQUE_123456"; + for (const key of [ + "Authorization", + "AUTHORIZATION", + "AuThOrIzAtIoN", + "Token", + "TOKEN", + "ToKeN", + "API_KEY", + "Cookie", + "COOKIE", + "Credential", + "Password", + "Secret", + "Auth", + "Access_Token", + "Proxy-Authorization", + "Passwd", + ]) { + for (const delimiter of [": ", "= "]) { + const input = `${key}${delimiter}${marker}`; + expect(redactSensitiveText(input), input).toBe("[REDACTED]"); + } + } + }); + + test("P1 regression: prose that mentions a key name survives", () => { + for (const text of [ + "the password is required to log in", + "set the secret before you start the server", + "The Authorization header is optional", + "Tokens expire after one hour", + "my_secret", + "github_token", + "api_key", + "Token", + "Secret", + "SECRETARY", + "TOKENS", + "PKI_KEYSTORE", + ]) { + expect(redactSensitiveText(text), text).toBe(text); + } + }); + + test("report names, details, and evidence are redacted, escaped, and capped", () => { + const report = summarizeCampaign([ + { + name: `probe\u001b[31m${syntheticSecret}`, + status: "fail", + detail: `token=${syntheticSecret}\u009b31m`, + evidence: Array.from( + { length: MAX_CAMPAIGN_REPORT_EVIDENCE_ITEMS + 20 }, + () => `password=${syntheticSecret}\u0000`, + ), + }, + ]); + const serialized = JSON.stringify(report); + expect(serialized).not.toContain(syntheticSecret); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(serialized)).toBe(false); + expect(report.results[0]?.detail).toContain("[REDACTED]"); + expect(report.results[0]?.evidence.length).toBe( + MAX_CAMPAIGN_REPORT_EVIDENCE_ITEMS, + ); + }); + + test("report redaction removes complete bearer credentials", () => { + const credential = "opaque-value-123456"; + const report = summarizeCampaign([ + { + name: "bearer", + status: "fail", + detail: `Authorization: Bearer ${credential}`, + evidence: [`Proxy-Authorization: Bearer proxy-${credential}`], + }, + ]); + const serialized = JSON.stringify(report); + expect(serialized).not.toContain(credential); + expect(serialized).toContain("[REDACTED]"); + }); + + test("report redaction removes control-interleaved bearer credentials", () => { + const credential = "SYNTHETIC_OPAQUE_123456"; + const report = summarizeCampaign([ + { + name: "interleaved-bearer", + status: "fail", + detail: `Authorization:\u001bBearer ${credential}`, + evidence: [`Proxy-Authorization:\u009bBearer ${credential}`], + }, + ]); + const serialized = JSON.stringify(report); + expect(serialized).not.toContain(credential); + expect(serialized).toContain("[REDACTED]"); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(serialized)).toBe(false); + }); + + test("report redaction covers every typed credential control insertion", () => { + const marker = "SYNTHETIC_OPAQUE_123456"; + const serialized = controlInterleavedAuthorizationCases(marker) + .map((text) => + JSON.stringify( + summarizeCampaign([ + { + name: "typed-credential", + status: "fail", + detail: text, + evidence: [`Proxy-${text}`], + }, + ]), + ), + ) + .join(""); + expect(serialized).not.toContain(marker); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(serialized)).toBe(false); + }); + + test("oversized reports retain an explicit limit failure", () => { + const report = summarizeCampaign( + Array.from({ length: MAX_CAMPAIGN_REPORT_RESULTS + 10 }, (_, index) => ({ + name: `probe.${index}`, + status: "pass" as const, + detail: "ok", + evidence: [], + })), + ); + expect(report.results).toHaveLength(MAX_CAMPAIGN_REPORT_RESULTS + 1); + expect(report.results.at(-1)).toMatchObject({ + name: "campaign:report-limit", + status: "fail", + }); + expect(report.ok).toBe(false); + }); + + test("target error fields and thrown secret messages never enter a report", async () => { + const marker = `SYNTHETIC_SECRET_DO_NOT_PERSIST\u001b]8;;`; + const dispatcher = new ScriptedCtlDispatcher(() => + makeErrorResult( + "core.terminal.spawn", + { + class: marker, + code: `\u009b${marker}`, + message: `authorization=${marker}`, + }, + EXIT_PERM, + ), + ); + const results = await probeEnvelopeConformance(dispatcher, [ + { + verb: "terminal.spawn", + args: ["terminal", "spawn"], + outcome: "ok", + elevated: false, + note: "synthetic", + }, + ]); + const serialized = JSON.stringify(results); + expect(serialized).not.toContain("SYNTHETIC_SECRET_DO_NOT_PERSIST"); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(serialized)).toBe(false); + + const thrown = new ScriptedCtlDispatcher(() => { + throw new Error(`authorization=${marker}\u001b[31m`); + }); + const thrownResults = await probeEnvelopeConformance(thrown, [ + { + verb: "terminal.spawn", + args: ["terminal", "spawn"], + outcome: "ok", + elevated: false, + note: "synthetic", + }, + ]); + const thrownSerialized = JSON.stringify(thrownResults); + expect(thrownSerialized).not.toContain("SYNTHETIC_SECRET_DO_NOT_PERSIST"); + expect(/[\u0000-\u001f\u007f-\u009f]/u.test(thrownSerialized)).toBe(false); + }); +}); + +describe("campaign owned-resource cleanup and per-verb authority", () => { + test("workspace cleanup always runs for the exact created id", async () => { + const dispatcher = campaignDispatcher(); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("pass"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2"]); + }); + + test("workspace cleanup survives malformed post-create observations", async () => { + const dispatcher = campaignDispatcher({ + "workspace.list.after-new": makeOkResult("core.workspace.list", { + workspaces: ["ws:2", 7], + }), + }); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2"]); + }); + + test("malformed workspace create responses still reconcile and clean new ids", async () => { + const dispatcher = campaignDispatcher({ + "workspace.new": makeOkResult("core.workspace.new", { + created: "opaque-create-response", + }), + }); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2"]); + }); + + test("workspace cleanup closes every unexpected new id exactly once", async () => { + const dispatcher = campaignDispatcher({ + "workspace.list.after-new": makeOkResult("core.workspace.list", { + workspaces: ["ws1", "ws2", "ws3", "ws3"], + names: ["", "", "", ""], + active: 4, + active_id: "ws:3", + count: 4, + tabline: "", + }), + }); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2", "ws:3"]); + }); + + test("workspace cleanup continues after one owned id fails", async () => { + const overrides: Record = { + "workspace.list.after-new": makeOkResult( + "core.workspace.list", + workspaceListResult(["ws1", "ws:2", "ws:3"], 3), + ), + }; + const dispatcher = attestFixtureDispatcher( + new ScriptedCtlDispatcher((invocation) => { + if ( + invocation.verb === "workspace.close" && + invocation.args[2] === "ws:2" + ) { + return makeErrorResult( + "core.workspace.close", + CONFLICT, + EXIT_CONFLICT, + ); + } + return overrides[invocation.verb] ?? resultFor(invocation); + }), + ); + const result = await probeWorkspaceIdRoundTrip(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2", "ws:3"]); + }); + + test("workspace focus and cleanup responses must match requested ids", async () => { + for (const overrides of [ + { + "workspace.focus": makeOkResult("core.workspace.focus", { + focused: "ws:9", + tabline: "", + }), + }, + { + "workspace.close": makeOkResult("core.workspace.close", { + closed: "ws:9", + killed: false, + tabline: "", + }), + }, + ]) { + const result = await probeWorkspaceIdRoundTrip( + campaignDispatcher(overrides), + ); + expect(result.status).toBe("fail"); + } + }); + + test("terminal cleanup closes only the created id and restores focus", async () => { + const dispatcher = campaignDispatcher(); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("pass"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "view.focus") + .map((invocation) => invocation.args[2]), + ).toEqual(["v:1"]); + }); + + test("terminal close and focus responses must match requested ids", async () => { + for (const overrides of [ + { + "terminal.close": makeOkResult("core.terminal.close", { + closed: "t:9", + }), + }, + { + "view.focus": makeOkResult("core.view.focus", { + focused: "v:9", + }), + }, + ]) { + const result = await probeTerminalSpawnObservability( + campaignDispatcher(overrides), + ); + expect(result.status).toBe("fail"); + } + }); + + test("extra post-spawn view deltas are rejected", async () => { + const dispatcher = campaignDispatcher({ + "view.list.after": makeOkResult("core.view.list", { + views: [ + { id: "v:1", focused: false }, + { id: "v:2", focused: true }, + { id: "v:3", focused: false }, + ], + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + }); + + test("terminal cleanup survives malformed post-spawn observations", async () => { + const dispatcher = campaignDispatcher({ + "view.list.after": makeOkResult("core.view.list", { + views: [{ id: "v:2" }], + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + }); + + test("malformed terminal spawn responses still reconcile and clean new ids", async () => { + const dispatcher = campaignDispatcher({ + "terminal.spawn": makeOkResult("core.terminal.spawn", { + spawned: true, + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + }); + + test("terminal cleanup closes every unexpected new id exactly once", async () => { + const dispatcher = campaignDispatcher({ + "view.list.after": makeOkResult("core.view.list", { + views: [ + { id: "v:1", focused: false }, + { id: "v:2", focused: true }, + { id: "v:3", focused: false }, + ], + }), + "terminal.list.after": makeOkResult("core.terminal.list", { + terminals: [ + { id: "t:1", has_pane_session: false }, + { id: "t:2", has_pane_session: true }, + { id: "t:3", has_pane_session: true }, + ], + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2", "t:3"]); + }); + + test("terminal cleanup continues after one owned id fails", async () => { + const overrides: Record = { + "view.list.after": makeOkResult("core.view.list", { + views: [ + { id: "v:1", focused: false }, + { id: "v:2", focused: true }, + { id: "v:3", focused: false }, + ], + }), + "terminal.list.after": makeOkResult("core.terminal.list", { + terminals: [ + { id: "t:1", has_pane_session: false }, + { id: "t:2", has_pane_session: true }, + { id: "t:3", has_pane_session: true }, + ], + }), + }; + const dispatcher = attestFixtureDispatcher( + new ScriptedCtlDispatcher((invocation) => { + if ( + invocation.verb === "terminal.close" && + invocation.args[2] === "t:2" + ) { + return makeErrorResult( + "core.terminal.close", + CONFLICT, + EXIT_CONFLICT, + ); + } + return overrides[invocation.verb] ?? resultFor(invocation); + }), + ); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2", "t:3"]); + }); + + test("inconsistent spawn identifiers still clean the new terminal", async () => { + const dispatcher = campaignDispatcher({ + "terminal.spawn": makeOkResult("core.terminal.spawn", { + spawned: true, + terminal_id: "t:2", + view_id: "v:1", + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + }); + + test("a baseline terminal reported by spawn is preserved while new ids are cleaned", async () => { + const dispatcher = campaignDispatcher({ + "terminal.spawn": makeOkResult("core.terminal.spawn", { + spawned: true, + terminal_id: "t:1", + view_id: "v:1", + }), + }); + const result = await probeTerminalSpawnObservability(dispatcher); + expect(result.status).toBe("fail"); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + }); + + test("full admitted campaign delegates creates once and cleans both resources", async () => { + const dispatcher = campaignDispatcher(); + const report = await runCampaign({ ...admittedCampaign, dispatcher }); + expect(report.ok).toBe(true); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.new"), + ).toHaveLength(1); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.spawn"), + ).toHaveLength(1); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "workspace.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["ws:2"]); + expect( + dispatcher + .seen() + .filter((invocation) => invocation.verb === "terminal.close") + .map((invocation) => invocation.args[2]), + ).toEqual(["t:2"]); + }); + + test("configured scope allowlist refuses unrelated elevated verbs", async () => { + let dispatches = 0; + const dispatcher = new ProcessCtlDispatcher( + { elevationScopes: "config.modify" }, + () => { + dispatches += 1; + return makeOkResult("core.terminal.spawn", { + spawned: true, + terminal_id: "t:2", + view_id: "v:2", + }); + }, + ); + await expect( + dispatcher.dispatch({ + verb: "terminal.spawn", + args: ["terminal", "spawn"], + elevated: true, + }), + ).rejects.toThrow(CampaignError); + expect(dispatches).toBe(0); + }); + + test("elevated announcements are selected per verb and unknown verbs fail closed", async () => { + const calls: Record[] = []; + const dispatcher = new ProcessCtlDispatcher( + {}, + (_program, _args, options) => { + calls.push(options.env); + return makeOkResult("core.terminal.spawn", { + spawned: true, + terminal_id: "t:2", + view_id: "v:2", + }); + }, + ); + + await dispatcher.dispatch({ + verb: "terminal.spawn", + args: ["terminal", "spawn"], + elevated: true, + }); + await dispatcher.dispatch({ + verb: "config.reload", + args: ["config", "reload"], + elevated: true, + }); + expect(calls[0]?.["BITTY_CTL_ELEVATE"]).toBe("terminal.manage"); + expect(calls[1]?.["BITTY_CTL_ELEVATE"]).toBe("config.modify"); + expect(calls[0]?.["BITTY_CTL_ELEVATE"]).not.toContain("config.modify"); + expect(calls[1]?.["BITTY_CTL_ELEVATE"]).not.toContain("terminal.manage"); + + await expect( + dispatcher.dispatch({ + verb: "unknown.elevated", + args: ["unknown"], + elevated: true, + }), + ).rejects.toThrow(CampaignError); + expect(calls).toHaveLength(2); + }); +}); diff --git a/tests/fixtures/redaction-normalization-class.txt b/tests/fixtures/redaction-normalization-class.txt new file mode 100644 index 0000000..99c1e92 --- /dev/null +++ b/tests/fixtures/redaction-normalization-class.txt @@ -0,0 +1,4515 @@ +# NORM-1 normalization class membership pin (generated, do not hand-edit). +# +# Definition (normative, mirrored in src/redaction.ts and +# crates/devtools-client/src/redaction.rs): every code point above U+007F that +# Unicode classifies as Default_Ignorable_Code_Point, as general category Cf +# (Other_Format), or as White_Space. Membership is decided by Unicode character +# properties only, so no hand-written range list is normative anywhere. +# +# Every member renders as nothing (format control or default-ignorable code +# point) or as blank (non-ASCII space separator), so a hostile producer can +# inject any of them to break a literal credential pattern match without +# changing what the operator sees. They are removed before secret matching and +# before human rendering. +# +# C0, DEL, and C1 controls are NOT in the class: they are escaped for +# rendering, never silently deleted. U+0085 is the single code point in both +# sets (Cc and White_Space); it is removed for matching and escaped for +# rendering. +# +# 4225 members in 29 ranges for Unicode 17.0 (Bun 1.4.2 / JavaScriptCore). +# Both the TypeScript and the Rust test suites execute this file, so a change +# of class membership on either side fails a gate instead of drifting. +# +# Columns: kindutf16_code_point_hex, one row per code point. +member 0085 +member 00A0 +member 00AD +member 034F +member 0600 +member 0601 +member 0602 +member 0603 +member 0604 +member 0605 +member 061C +member 06DD +member 070F +member 0890 +member 0891 +member 08E2 +member 115F +member 1160 +member 1680 +member 17B4 +member 17B5 +member 180B +member 180C +member 180D +member 180E +member 180F +member 2000 +member 2001 +member 2002 +member 2003 +member 2004 +member 2005 +member 2006 +member 2007 +member 2008 +member 2009 +member 200A +member 200B +member 200C +member 200D +member 200E +member 200F +member 2028 +member 2029 +member 202A +member 202B +member 202C +member 202D +member 202E +member 202F +member 205F +member 2060 +member 2061 +member 2062 +member 2063 +member 2064 +member 2065 +member 2066 +member 2067 +member 2068 +member 2069 +member 206A +member 206B +member 206C +member 206D +member 206E +member 206F +member 3000 +member 3164 +member FE00 +member FE01 +member FE02 +member FE03 +member FE04 +member FE05 +member FE06 +member FE07 +member FE08 +member FE09 +member FE0A +member FE0B +member FE0C +member FE0D +member FE0E +member FE0F +member FEFF +member FFA0 +member FFF0 +member FFF1 +member FFF2 +member FFF3 +member FFF4 +member FFF5 +member FFF6 +member FFF7 +member FFF8 +member FFF9 +member FFFA +member FFFB +member 110BD +member 110CD +member 13430 +member 13431 +member 13432 +member 13433 +member 13434 +member 13435 +member 13436 +member 13437 +member 13438 +member 13439 +member 1343A +member 1343B +member 1343C +member 1343D +member 1343E +member 1343F +member 1BCA0 +member 1BCA1 +member 1BCA2 +member 1BCA3 +member 1D173 +member 1D174 +member 1D175 +member 1D176 +member 1D177 +member 1D178 +member 1D179 +member 1D17A +member E0000 +member E0001 +member E0002 +member E0003 +member E0004 +member E0005 +member E0006 +member E0007 +member E0008 +member E0009 +member E000A +member E000B +member E000C +member E000D +member E000E +member E000F +member E0010 +member E0011 +member E0012 +member E0013 +member E0014 +member E0015 +member E0016 +member E0017 +member E0018 +member E0019 +member E001A +member E001B +member E001C +member E001D +member E001E +member E001F +member E0020 +member E0021 +member E0022 +member E0023 +member E0024 +member E0025 +member E0026 +member E0027 +member E0028 +member E0029 +member E002A +member E002B +member E002C +member E002D +member E002E +member E002F +member E0030 +member E0031 +member E0032 +member E0033 +member E0034 +member E0035 +member E0036 +member E0037 +member E0038 +member E0039 +member E003A +member E003B +member E003C +member E003D +member E003E +member E003F +member E0040 +member E0041 +member E0042 +member E0043 +member E0044 +member E0045 +member E0046 +member E0047 +member E0048 +member E0049 +member E004A +member E004B +member E004C +member E004D +member E004E +member E004F +member E0050 +member E0051 +member E0052 +member E0053 +member E0054 +member E0055 +member E0056 +member E0057 +member E0058 +member E0059 +member E005A +member E005B +member E005C +member E005D +member E005E +member E005F +member E0060 +member E0061 +member E0062 +member E0063 +member E0064 +member E0065 +member E0066 +member E0067 +member E0068 +member E0069 +member E006A +member E006B +member E006C +member E006D +member E006E +member E006F +member E0070 +member E0071 +member E0072 +member E0073 +member E0074 +member E0075 +member E0076 +member E0077 +member E0078 +member E0079 +member E007A +member E007B +member E007C +member E007D +member E007E +member E007F +member E0080 +member E0081 +member E0082 +member E0083 +member E0084 +member E0085 +member E0086 +member E0087 +member E0088 +member E0089 +member E008A +member E008B +member E008C +member E008D +member E008E +member E008F +member E0090 +member E0091 +member E0092 +member E0093 +member E0094 +member E0095 +member E0096 +member E0097 +member E0098 +member E0099 +member E009A +member E009B +member E009C +member E009D +member E009E +member E009F +member E00A0 +member E00A1 +member E00A2 +member E00A3 +member E00A4 +member E00A5 +member E00A6 +member E00A7 +member E00A8 +member E00A9 +member E00AA +member E00AB +member E00AC +member E00AD +member E00AE +member E00AF +member E00B0 +member E00B1 +member E00B2 +member E00B3 +member E00B4 +member E00B5 +member E00B6 +member E00B7 +member E00B8 +member E00B9 +member E00BA +member E00BB +member E00BC +member E00BD +member E00BE +member E00BF +member E00C0 +member E00C1 +member E00C2 +member E00C3 +member E00C4 +member E00C5 +member E00C6 +member E00C7 +member E00C8 +member E00C9 +member E00CA +member E00CB +member E00CC +member E00CD +member E00CE +member E00CF +member E00D0 +member E00D1 +member E00D2 +member E00D3 +member E00D4 +member E00D5 +member E00D6 +member E00D7 +member E00D8 +member E00D9 +member E00DA +member E00DB +member E00DC +member E00DD +member E00DE +member E00DF +member E00E0 +member E00E1 +member E00E2 +member E00E3 +member E00E4 +member E00E5 +member E00E6 +member E00E7 +member E00E8 +member E00E9 +member E00EA +member E00EB +member E00EC +member E00ED +member E00EE +member E00EF +member E00F0 +member E00F1 +member E00F2 +member E00F3 +member E00F4 +member E00F5 +member E00F6 +member E00F7 +member E00F8 +member E00F9 +member E00FA +member E00FB +member E00FC +member E00FD +member E00FE +member E00FF +member E0100 +member E0101 +member E0102 +member E0103 +member E0104 +member E0105 +member E0106 +member E0107 +member E0108 +member E0109 +member E010A +member E010B +member E010C +member E010D +member E010E +member E010F +member E0110 +member E0111 +member E0112 +member E0113 +member E0114 +member E0115 +member E0116 +member E0117 +member E0118 +member E0119 +member E011A +member E011B +member E011C +member E011D +member E011E +member E011F +member E0120 +member E0121 +member E0122 +member E0123 +member E0124 +member E0125 +member E0126 +member E0127 +member E0128 +member E0129 +member E012A +member E012B +member E012C +member E012D +member E012E +member E012F +member E0130 +member E0131 +member E0132 +member E0133 +member E0134 +member E0135 +member E0136 +member E0137 +member E0138 +member E0139 +member E013A +member E013B +member E013C +member E013D +member E013E +member E013F +member E0140 +member E0141 +member E0142 +member E0143 +member E0144 +member E0145 +member E0146 +member E0147 +member E0148 +member E0149 +member E014A +member E014B +member E014C +member E014D +member E014E +member E014F +member E0150 +member E0151 +member E0152 +member E0153 +member E0154 +member E0155 +member E0156 +member E0157 +member E0158 +member E0159 +member E015A +member E015B +member E015C +member E015D +member E015E +member E015F +member E0160 +member E0161 +member E0162 +member E0163 +member E0164 +member E0165 +member E0166 +member E0167 +member E0168 +member E0169 +member E016A +member E016B +member E016C +member E016D +member E016E +member E016F +member E0170 +member E0171 +member E0172 +member E0173 +member E0174 +member E0175 +member E0176 +member E0177 +member E0178 +member E0179 +member E017A +member E017B +member E017C +member E017D +member E017E +member E017F +member E0180 +member E0181 +member E0182 +member E0183 +member E0184 +member E0185 +member E0186 +member E0187 +member E0188 +member E0189 +member E018A +member E018B +member E018C +member E018D +member E018E +member E018F +member E0190 +member E0191 +member E0192 +member E0193 +member E0194 +member E0195 +member E0196 +member E0197 +member E0198 +member E0199 +member E019A +member E019B +member E019C +member E019D +member E019E +member E019F +member E01A0 +member E01A1 +member E01A2 +member E01A3 +member E01A4 +member E01A5 +member E01A6 +member E01A7 +member E01A8 +member E01A9 +member E01AA +member E01AB +member E01AC +member E01AD +member E01AE +member E01AF +member E01B0 +member E01B1 +member E01B2 +member E01B3 +member E01B4 +member E01B5 +member E01B6 +member E01B7 +member E01B8 +member E01B9 +member E01BA +member E01BB +member E01BC +member E01BD +member E01BE +member E01BF +member E01C0 +member E01C1 +member E01C2 +member E01C3 +member E01C4 +member E01C5 +member E01C6 +member E01C7 +member E01C8 +member E01C9 +member E01CA +member E01CB +member E01CC +member E01CD +member E01CE +member E01CF +member E01D0 +member E01D1 +member E01D2 +member E01D3 +member E01D4 +member E01D5 +member E01D6 +member E01D7 +member E01D8 +member E01D9 +member E01DA +member E01DB +member E01DC +member E01DD +member E01DE +member E01DF +member E01E0 +member E01E1 +member E01E2 +member E01E3 +member E01E4 +member E01E5 +member E01E6 +member E01E7 +member E01E8 +member E01E9 +member E01EA +member E01EB +member E01EC +member E01ED +member E01EE +member E01EF +member E01F0 +member E01F1 +member E01F2 +member E01F3 +member E01F4 +member E01F5 +member E01F6 +member E01F7 +member E01F8 +member E01F9 +member E01FA +member E01FB +member E01FC +member E01FD +member E01FE +member E01FF +member E0200 +member E0201 +member E0202 +member E0203 +member E0204 +member E0205 +member E0206 +member E0207 +member E0208 +member E0209 +member E020A +member E020B +member E020C +member E020D +member E020E +member E020F +member E0210 +member E0211 +member E0212 +member E0213 +member E0214 +member E0215 +member E0216 +member E0217 +member E0218 +member E0219 +member E021A +member E021B +member E021C +member E021D +member E021E +member E021F +member E0220 +member E0221 +member E0222 +member E0223 +member E0224 +member E0225 +member E0226 +member E0227 +member E0228 +member E0229 +member E022A +member E022B +member E022C +member E022D +member E022E +member E022F +member E0230 +member E0231 +member E0232 +member E0233 +member E0234 +member E0235 +member E0236 +member E0237 +member E0238 +member E0239 +member E023A +member E023B +member E023C +member E023D +member E023E +member E023F +member E0240 +member E0241 +member E0242 +member E0243 +member E0244 +member E0245 +member E0246 +member E0247 +member E0248 +member E0249 +member E024A +member E024B +member E024C +member E024D +member E024E +member E024F +member E0250 +member E0251 +member E0252 +member E0253 +member E0254 +member E0255 +member E0256 +member E0257 +member E0258 +member E0259 +member E025A +member E025B +member E025C +member E025D +member E025E +member E025F +member E0260 +member E0261 +member E0262 +member E0263 +member E0264 +member E0265 +member E0266 +member E0267 +member E0268 +member E0269 +member E026A +member E026B +member E026C +member E026D +member E026E +member E026F +member E0270 +member E0271 +member E0272 +member E0273 +member E0274 +member E0275 +member E0276 +member E0277 +member E0278 +member E0279 +member E027A +member E027B +member E027C +member E027D +member E027E +member E027F +member E0280 +member E0281 +member E0282 +member E0283 +member E0284 +member E0285 +member E0286 +member E0287 +member E0288 +member E0289 +member E028A +member E028B +member E028C +member E028D +member E028E +member E028F +member E0290 +member E0291 +member E0292 +member E0293 +member E0294 +member E0295 +member E0296 +member E0297 +member E0298 +member E0299 +member E029A +member E029B +member E029C +member E029D +member E029E +member E029F +member E02A0 +member E02A1 +member E02A2 +member E02A3 +member E02A4 +member E02A5 +member E02A6 +member E02A7 +member E02A8 +member E02A9 +member E02AA +member E02AB +member E02AC +member E02AD +member E02AE +member E02AF +member E02B0 +member E02B1 +member E02B2 +member E02B3 +member E02B4 +member E02B5 +member E02B6 +member E02B7 +member E02B8 +member E02B9 +member E02BA +member E02BB +member E02BC +member E02BD +member E02BE +member E02BF +member E02C0 +member E02C1 +member E02C2 +member E02C3 +member E02C4 +member E02C5 +member E02C6 +member E02C7 +member E02C8 +member E02C9 +member E02CA +member E02CB +member E02CC +member E02CD +member E02CE +member E02CF +member E02D0 +member E02D1 +member E02D2 +member E02D3 +member E02D4 +member E02D5 +member E02D6 +member E02D7 +member E02D8 +member E02D9 +member E02DA +member E02DB +member E02DC +member E02DD +member E02DE +member E02DF +member E02E0 +member E02E1 +member E02E2 +member E02E3 +member E02E4 +member E02E5 +member E02E6 +member E02E7 +member E02E8 +member E02E9 +member E02EA +member E02EB +member E02EC +member E02ED +member E02EE +member E02EF +member E02F0 +member E02F1 +member E02F2 +member E02F3 +member E02F4 +member E02F5 +member E02F6 +member E02F7 +member E02F8 +member E02F9 +member E02FA +member E02FB +member E02FC +member E02FD +member E02FE +member E02FF +member E0300 +member E0301 +member E0302 +member E0303 +member E0304 +member E0305 +member E0306 +member E0307 +member E0308 +member E0309 +member E030A +member E030B +member E030C +member E030D +member E030E +member E030F +member E0310 +member E0311 +member E0312 +member E0313 +member E0314 +member E0315 +member E0316 +member E0317 +member E0318 +member E0319 +member E031A +member E031B +member E031C +member E031D +member E031E +member E031F +member E0320 +member E0321 +member E0322 +member E0323 +member E0324 +member E0325 +member E0326 +member E0327 +member E0328 +member E0329 +member E032A +member E032B +member E032C +member E032D +member E032E +member E032F +member E0330 +member E0331 +member E0332 +member E0333 +member E0334 +member E0335 +member E0336 +member E0337 +member E0338 +member E0339 +member E033A +member E033B +member E033C +member E033D +member E033E +member E033F +member E0340 +member E0341 +member E0342 +member E0343 +member E0344 +member E0345 +member E0346 +member E0347 +member E0348 +member E0349 +member E034A +member E034B +member E034C +member E034D +member E034E +member E034F +member E0350 +member E0351 +member E0352 +member E0353 +member E0354 +member E0355 +member E0356 +member E0357 +member E0358 +member E0359 +member E035A +member E035B +member E035C +member E035D +member E035E +member E035F +member E0360 +member E0361 +member E0362 +member E0363 +member E0364 +member E0365 +member E0366 +member E0367 +member E0368 +member E0369 +member E036A +member E036B +member E036C +member E036D +member E036E +member E036F +member E0370 +member E0371 +member E0372 +member E0373 +member E0374 +member E0375 +member E0376 +member E0377 +member E0378 +member E0379 +member E037A +member E037B +member E037C +member E037D +member E037E +member E037F +member E0380 +member E0381 +member E0382 +member E0383 +member E0384 +member E0385 +member E0386 +member E0387 +member E0388 +member E0389 +member E038A +member E038B +member E038C +member E038D +member E038E +member E038F +member E0390 +member E0391 +member E0392 +member E0393 +member E0394 +member E0395 +member E0396 +member E0397 +member E0398 +member E0399 +member E039A +member E039B +member E039C +member E039D +member E039E +member E039F +member E03A0 +member E03A1 +member E03A2 +member E03A3 +member E03A4 +member E03A5 +member E03A6 +member E03A7 +member E03A8 +member E03A9 +member E03AA +member E03AB +member E03AC +member E03AD +member E03AE +member E03AF +member E03B0 +member E03B1 +member E03B2 +member E03B3 +member E03B4 +member E03B5 +member E03B6 +member E03B7 +member E03B8 +member E03B9 +member E03BA +member E03BB +member E03BC +member E03BD +member E03BE +member E03BF +member E03C0 +member E03C1 +member E03C2 +member E03C3 +member E03C4 +member E03C5 +member E03C6 +member E03C7 +member E03C8 +member E03C9 +member E03CA +member E03CB +member E03CC +member E03CD +member E03CE +member E03CF +member E03D0 +member E03D1 +member E03D2 +member E03D3 +member E03D4 +member E03D5 +member E03D6 +member E03D7 +member E03D8 +member E03D9 +member E03DA +member E03DB +member E03DC +member E03DD +member E03DE +member E03DF +member E03E0 +member E03E1 +member E03E2 +member E03E3 +member E03E4 +member E03E5 +member E03E6 +member E03E7 +member E03E8 +member E03E9 +member E03EA +member E03EB +member E03EC +member E03ED +member E03EE +member E03EF +member E03F0 +member E03F1 +member E03F2 +member E03F3 +member E03F4 +member E03F5 +member E03F6 +member E03F7 +member E03F8 +member E03F9 +member E03FA +member E03FB +member E03FC +member E03FD +member E03FE +member E03FF +member E0400 +member E0401 +member E0402 +member E0403 +member E0404 +member E0405 +member E0406 +member E0407 +member E0408 +member E0409 +member E040A +member E040B +member E040C +member E040D +member E040E +member E040F +member E0410 +member E0411 +member E0412 +member E0413 +member E0414 +member E0415 +member E0416 +member E0417 +member E0418 +member E0419 +member E041A +member E041B +member E041C +member E041D +member E041E +member E041F +member E0420 +member E0421 +member E0422 +member E0423 +member E0424 +member E0425 +member E0426 +member E0427 +member E0428 +member E0429 +member E042A +member E042B +member E042C +member E042D +member E042E +member E042F +member E0430 +member E0431 +member E0432 +member E0433 +member E0434 +member E0435 +member E0436 +member E0437 +member E0438 +member E0439 +member E043A +member E043B +member E043C +member E043D +member E043E +member E043F +member E0440 +member E0441 +member E0442 +member E0443 +member E0444 +member E0445 +member E0446 +member E0447 +member E0448 +member E0449 +member E044A +member E044B +member E044C +member E044D +member E044E +member E044F +member E0450 +member E0451 +member E0452 +member E0453 +member E0454 +member E0455 +member E0456 +member E0457 +member E0458 +member E0459 +member E045A +member E045B +member E045C +member E045D +member E045E +member E045F +member E0460 +member E0461 +member E0462 +member E0463 +member E0464 +member E0465 +member E0466 +member E0467 +member E0468 +member E0469 +member E046A +member E046B +member E046C +member E046D +member E046E +member E046F +member E0470 +member E0471 +member E0472 +member E0473 +member E0474 +member E0475 +member E0476 +member E0477 +member E0478 +member E0479 +member E047A +member E047B +member E047C +member E047D +member E047E +member E047F +member E0480 +member E0481 +member E0482 +member E0483 +member E0484 +member E0485 +member E0486 +member E0487 +member E0488 +member E0489 +member E048A +member E048B +member E048C +member E048D +member E048E +member E048F +member E0490 +member E0491 +member E0492 +member E0493 +member E0494 +member E0495 +member E0496 +member E0497 +member E0498 +member E0499 +member E049A +member E049B +member E049C +member E049D +member E049E +member E049F +member E04A0 +member E04A1 +member E04A2 +member E04A3 +member E04A4 +member E04A5 +member E04A6 +member E04A7 +member E04A8 +member E04A9 +member E04AA +member E04AB +member E04AC +member E04AD +member E04AE +member E04AF +member E04B0 +member E04B1 +member E04B2 +member E04B3 +member E04B4 +member E04B5 +member E04B6 +member E04B7 +member E04B8 +member E04B9 +member E04BA +member E04BB +member E04BC +member E04BD +member E04BE +member E04BF +member E04C0 +member E04C1 +member E04C2 +member E04C3 +member E04C4 +member E04C5 +member E04C6 +member E04C7 +member E04C8 +member E04C9 +member E04CA +member E04CB +member E04CC +member E04CD +member E04CE +member E04CF +member E04D0 +member E04D1 +member E04D2 +member E04D3 +member E04D4 +member E04D5 +member E04D6 +member E04D7 +member E04D8 +member E04D9 +member E04DA +member E04DB +member E04DC +member E04DD +member E04DE +member E04DF +member E04E0 +member E04E1 +member E04E2 +member E04E3 +member E04E4 +member E04E5 +member E04E6 +member E04E7 +member E04E8 +member E04E9 +member E04EA +member E04EB +member E04EC +member E04ED +member E04EE +member E04EF +member E04F0 +member E04F1 +member E04F2 +member E04F3 +member E04F4 +member E04F5 +member E04F6 +member E04F7 +member E04F8 +member E04F9 +member E04FA +member E04FB +member E04FC +member E04FD +member E04FE +member E04FF +member E0500 +member E0501 +member E0502 +member E0503 +member E0504 +member E0505 +member E0506 +member E0507 +member E0508 +member E0509 +member E050A +member E050B +member E050C +member E050D +member E050E +member E050F +member E0510 +member E0511 +member E0512 +member E0513 +member E0514 +member E0515 +member E0516 +member E0517 +member E0518 +member E0519 +member E051A +member E051B +member E051C +member E051D +member E051E +member E051F +member E0520 +member E0521 +member E0522 +member E0523 +member E0524 +member E0525 +member E0526 +member E0527 +member E0528 +member E0529 +member E052A +member E052B +member E052C +member E052D +member E052E +member E052F +member E0530 +member E0531 +member E0532 +member E0533 +member E0534 +member E0535 +member E0536 +member E0537 +member E0538 +member E0539 +member E053A +member E053B +member E053C +member E053D +member E053E +member E053F +member E0540 +member E0541 +member E0542 +member E0543 +member E0544 +member E0545 +member E0546 +member E0547 +member E0548 +member E0549 +member E054A +member E054B +member E054C +member E054D +member E054E +member E054F +member E0550 +member E0551 +member E0552 +member E0553 +member E0554 +member E0555 +member E0556 +member E0557 +member E0558 +member E0559 +member E055A +member E055B +member E055C +member E055D +member E055E +member E055F +member E0560 +member E0561 +member E0562 +member E0563 +member E0564 +member E0565 +member E0566 +member E0567 +member E0568 +member E0569 +member E056A +member E056B +member E056C +member E056D +member E056E +member E056F +member E0570 +member E0571 +member E0572 +member E0573 +member E0574 +member E0575 +member E0576 +member E0577 +member E0578 +member E0579 +member E057A +member E057B +member E057C +member E057D +member E057E +member E057F +member E0580 +member E0581 +member E0582 +member E0583 +member E0584 +member E0585 +member E0586 +member E0587 +member E0588 +member E0589 +member E058A +member E058B +member E058C +member E058D +member E058E +member E058F +member E0590 +member E0591 +member E0592 +member E0593 +member E0594 +member E0595 +member E0596 +member E0597 +member E0598 +member E0599 +member E059A +member E059B +member E059C +member E059D +member E059E +member E059F +member E05A0 +member E05A1 +member E05A2 +member E05A3 +member E05A4 +member E05A5 +member E05A6 +member E05A7 +member E05A8 +member E05A9 +member E05AA +member E05AB +member E05AC +member E05AD +member E05AE +member E05AF +member E05B0 +member E05B1 +member E05B2 +member E05B3 +member E05B4 +member E05B5 +member E05B6 +member E05B7 +member E05B8 +member E05B9 +member E05BA +member E05BB +member E05BC +member E05BD +member E05BE +member E05BF +member E05C0 +member E05C1 +member E05C2 +member E05C3 +member E05C4 +member E05C5 +member E05C6 +member E05C7 +member E05C8 +member E05C9 +member E05CA +member E05CB +member E05CC +member E05CD +member E05CE +member E05CF +member E05D0 +member E05D1 +member E05D2 +member E05D3 +member E05D4 +member E05D5 +member E05D6 +member E05D7 +member E05D8 +member E05D9 +member E05DA +member E05DB +member E05DC +member E05DD +member E05DE +member E05DF +member E05E0 +member E05E1 +member E05E2 +member E05E3 +member E05E4 +member E05E5 +member E05E6 +member E05E7 +member E05E8 +member E05E9 +member E05EA +member E05EB +member E05EC +member E05ED +member E05EE +member E05EF +member E05F0 +member E05F1 +member E05F2 +member E05F3 +member E05F4 +member E05F5 +member E05F6 +member E05F7 +member E05F8 +member E05F9 +member E05FA +member E05FB +member E05FC +member E05FD +member E05FE +member E05FF +member E0600 +member E0601 +member E0602 +member E0603 +member E0604 +member E0605 +member E0606 +member E0607 +member E0608 +member E0609 +member E060A +member E060B +member E060C +member E060D +member E060E +member E060F +member E0610 +member E0611 +member E0612 +member E0613 +member E0614 +member E0615 +member E0616 +member E0617 +member E0618 +member E0619 +member E061A +member E061B +member E061C +member E061D +member E061E +member E061F +member E0620 +member E0621 +member E0622 +member E0623 +member E0624 +member E0625 +member E0626 +member E0627 +member E0628 +member E0629 +member E062A +member E062B +member E062C +member E062D +member E062E +member E062F +member E0630 +member E0631 +member E0632 +member E0633 +member E0634 +member E0635 +member E0636 +member E0637 +member E0638 +member E0639 +member E063A +member E063B +member E063C +member E063D +member E063E +member E063F +member E0640 +member E0641 +member E0642 +member E0643 +member E0644 +member E0645 +member E0646 +member E0647 +member E0648 +member E0649 +member E064A +member E064B +member E064C +member E064D +member E064E +member E064F +member E0650 +member E0651 +member E0652 +member E0653 +member E0654 +member E0655 +member E0656 +member E0657 +member E0658 +member E0659 +member E065A +member E065B +member E065C +member E065D +member E065E +member E065F +member E0660 +member E0661 +member E0662 +member E0663 +member E0664 +member E0665 +member E0666 +member E0667 +member E0668 +member E0669 +member E066A +member E066B +member E066C +member E066D +member E066E +member E066F +member E0670 +member E0671 +member E0672 +member E0673 +member E0674 +member E0675 +member E0676 +member E0677 +member E0678 +member E0679 +member E067A +member E067B +member E067C +member E067D +member E067E +member E067F +member E0680 +member E0681 +member E0682 +member E0683 +member E0684 +member E0685 +member E0686 +member E0687 +member E0688 +member E0689 +member E068A +member E068B +member E068C +member E068D +member E068E +member E068F +member E0690 +member E0691 +member E0692 +member E0693 +member E0694 +member E0695 +member E0696 +member E0697 +member E0698 +member E0699 +member E069A +member E069B +member E069C +member E069D +member E069E +member E069F +member E06A0 +member E06A1 +member E06A2 +member E06A3 +member E06A4 +member E06A5 +member E06A6 +member E06A7 +member E06A8 +member E06A9 +member E06AA +member E06AB +member E06AC +member E06AD +member E06AE +member E06AF +member E06B0 +member E06B1 +member E06B2 +member E06B3 +member E06B4 +member E06B5 +member E06B6 +member E06B7 +member E06B8 +member E06B9 +member E06BA +member E06BB +member E06BC +member E06BD +member E06BE +member E06BF +member E06C0 +member E06C1 +member E06C2 +member E06C3 +member E06C4 +member E06C5 +member E06C6 +member E06C7 +member E06C8 +member E06C9 +member E06CA +member E06CB +member E06CC +member E06CD +member E06CE +member E06CF +member E06D0 +member E06D1 +member E06D2 +member E06D3 +member E06D4 +member E06D5 +member E06D6 +member E06D7 +member E06D8 +member E06D9 +member E06DA +member E06DB +member E06DC +member E06DD +member E06DE +member E06DF +member E06E0 +member E06E1 +member E06E2 +member E06E3 +member E06E4 +member E06E5 +member E06E6 +member E06E7 +member E06E8 +member E06E9 +member E06EA +member E06EB +member E06EC +member E06ED +member E06EE +member E06EF +member E06F0 +member E06F1 +member E06F2 +member E06F3 +member E06F4 +member E06F5 +member E06F6 +member E06F7 +member E06F8 +member E06F9 +member E06FA +member E06FB +member E06FC +member E06FD +member E06FE +member E06FF +member E0700 +member E0701 +member E0702 +member E0703 +member E0704 +member E0705 +member E0706 +member E0707 +member E0708 +member E0709 +member E070A +member E070B +member E070C +member E070D +member E070E +member E070F +member E0710 +member E0711 +member E0712 +member E0713 +member E0714 +member E0715 +member E0716 +member E0717 +member E0718 +member E0719 +member E071A +member E071B +member E071C +member E071D +member E071E +member E071F +member E0720 +member E0721 +member E0722 +member E0723 +member E0724 +member E0725 +member E0726 +member E0727 +member E0728 +member E0729 +member E072A +member E072B +member E072C +member E072D +member E072E +member E072F +member E0730 +member E0731 +member E0732 +member E0733 +member E0734 +member E0735 +member E0736 +member E0737 +member E0738 +member E0739 +member E073A +member E073B +member E073C +member E073D +member E073E +member E073F +member E0740 +member E0741 +member E0742 +member E0743 +member E0744 +member E0745 +member E0746 +member E0747 +member E0748 +member E0749 +member E074A +member E074B +member E074C +member E074D +member E074E +member E074F +member E0750 +member E0751 +member E0752 +member E0753 +member E0754 +member E0755 +member E0756 +member E0757 +member E0758 +member E0759 +member E075A +member E075B +member E075C +member E075D +member E075E +member E075F +member E0760 +member E0761 +member E0762 +member E0763 +member E0764 +member E0765 +member E0766 +member E0767 +member E0768 +member E0769 +member E076A +member E076B +member E076C +member E076D +member E076E +member E076F +member E0770 +member E0771 +member E0772 +member E0773 +member E0774 +member E0775 +member E0776 +member E0777 +member E0778 +member E0779 +member E077A +member E077B +member E077C +member E077D +member E077E +member E077F +member E0780 +member E0781 +member E0782 +member E0783 +member E0784 +member E0785 +member E0786 +member E0787 +member E0788 +member E0789 +member E078A +member E078B +member E078C +member E078D +member E078E +member E078F +member E0790 +member E0791 +member E0792 +member E0793 +member E0794 +member E0795 +member E0796 +member E0797 +member E0798 +member E0799 +member E079A +member E079B +member E079C +member E079D +member E079E +member E079F +member E07A0 +member E07A1 +member E07A2 +member E07A3 +member E07A4 +member E07A5 +member E07A6 +member E07A7 +member E07A8 +member E07A9 +member E07AA +member E07AB +member E07AC +member E07AD +member E07AE +member E07AF +member E07B0 +member E07B1 +member E07B2 +member E07B3 +member E07B4 +member E07B5 +member E07B6 +member E07B7 +member E07B8 +member E07B9 +member E07BA +member E07BB +member E07BC +member E07BD +member E07BE +member E07BF +member E07C0 +member E07C1 +member E07C2 +member E07C3 +member E07C4 +member E07C5 +member E07C6 +member E07C7 +member E07C8 +member E07C9 +member E07CA +member E07CB +member E07CC +member E07CD +member E07CE +member E07CF +member E07D0 +member E07D1 +member E07D2 +member E07D3 +member E07D4 +member E07D5 +member E07D6 +member E07D7 +member E07D8 +member E07D9 +member E07DA +member E07DB +member E07DC +member E07DD +member E07DE +member E07DF +member E07E0 +member E07E1 +member E07E2 +member E07E3 +member E07E4 +member E07E5 +member E07E6 +member E07E7 +member E07E8 +member E07E9 +member E07EA +member E07EB +member E07EC +member E07ED +member E07EE +member E07EF +member E07F0 +member E07F1 +member E07F2 +member E07F3 +member E07F4 +member E07F5 +member E07F6 +member E07F7 +member E07F8 +member E07F9 +member E07FA +member E07FB +member E07FC +member E07FD +member E07FE +member E07FF +member E0800 +member E0801 +member E0802 +member E0803 +member E0804 +member E0805 +member E0806 +member E0807 +member E0808 +member E0809 +member E080A +member E080B +member E080C +member E080D +member E080E +member E080F +member E0810 +member E0811 +member E0812 +member E0813 +member E0814 +member E0815 +member E0816 +member E0817 +member E0818 +member E0819 +member E081A +member E081B +member E081C +member E081D +member E081E +member E081F +member E0820 +member E0821 +member E0822 +member E0823 +member E0824 +member E0825 +member E0826 +member E0827 +member E0828 +member E0829 +member E082A +member E082B +member E082C +member E082D +member E082E +member E082F +member E0830 +member E0831 +member E0832 +member E0833 +member E0834 +member E0835 +member E0836 +member E0837 +member E0838 +member E0839 +member E083A +member E083B +member E083C +member E083D +member E083E +member E083F +member E0840 +member E0841 +member E0842 +member E0843 +member E0844 +member E0845 +member E0846 +member E0847 +member E0848 +member E0849 +member E084A +member E084B +member E084C +member E084D +member E084E +member E084F +member E0850 +member E0851 +member E0852 +member E0853 +member E0854 +member E0855 +member E0856 +member E0857 +member E0858 +member E0859 +member E085A +member E085B +member E085C +member E085D +member E085E +member E085F +member E0860 +member E0861 +member E0862 +member E0863 +member E0864 +member E0865 +member E0866 +member E0867 +member E0868 +member E0869 +member E086A +member E086B +member E086C +member E086D +member E086E +member E086F +member E0870 +member E0871 +member E0872 +member E0873 +member E0874 +member E0875 +member E0876 +member E0877 +member E0878 +member E0879 +member E087A +member E087B +member E087C +member E087D +member E087E +member E087F +member E0880 +member E0881 +member E0882 +member E0883 +member E0884 +member E0885 +member E0886 +member E0887 +member E0888 +member E0889 +member E088A +member E088B +member E088C +member E088D +member E088E +member E088F +member E0890 +member E0891 +member E0892 +member E0893 +member E0894 +member E0895 +member E0896 +member E0897 +member E0898 +member E0899 +member E089A +member E089B +member E089C +member E089D +member E089E +member E089F +member E08A0 +member E08A1 +member E08A2 +member E08A3 +member E08A4 +member E08A5 +member E08A6 +member E08A7 +member E08A8 +member E08A9 +member E08AA +member E08AB +member E08AC +member E08AD +member E08AE +member E08AF +member E08B0 +member E08B1 +member E08B2 +member E08B3 +member E08B4 +member E08B5 +member E08B6 +member E08B7 +member E08B8 +member E08B9 +member E08BA +member E08BB +member E08BC +member E08BD +member E08BE +member E08BF +member E08C0 +member E08C1 +member E08C2 +member E08C3 +member E08C4 +member E08C5 +member E08C6 +member E08C7 +member E08C8 +member E08C9 +member E08CA +member E08CB +member E08CC +member E08CD +member E08CE +member E08CF +member E08D0 +member E08D1 +member E08D2 +member E08D3 +member E08D4 +member E08D5 +member E08D6 +member E08D7 +member E08D8 +member E08D9 +member E08DA +member E08DB +member E08DC +member E08DD +member E08DE +member E08DF +member E08E0 +member E08E1 +member E08E2 +member E08E3 +member E08E4 +member E08E5 +member E08E6 +member E08E7 +member E08E8 +member E08E9 +member E08EA +member E08EB +member E08EC +member E08ED +member E08EE +member E08EF +member E08F0 +member E08F1 +member E08F2 +member E08F3 +member E08F4 +member E08F5 +member E08F6 +member E08F7 +member E08F8 +member E08F9 +member E08FA +member E08FB +member E08FC +member E08FD +member E08FE +member E08FF +member E0900 +member E0901 +member E0902 +member E0903 +member E0904 +member E0905 +member E0906 +member E0907 +member E0908 +member E0909 +member E090A +member E090B +member E090C +member E090D +member E090E +member E090F +member E0910 +member E0911 +member E0912 +member E0913 +member E0914 +member E0915 +member E0916 +member E0917 +member E0918 +member E0919 +member E091A +member E091B +member E091C +member E091D +member E091E +member E091F +member E0920 +member E0921 +member E0922 +member E0923 +member E0924 +member E0925 +member E0926 +member E0927 +member E0928 +member E0929 +member E092A +member E092B +member E092C +member E092D +member E092E +member E092F +member E0930 +member E0931 +member E0932 +member E0933 +member E0934 +member E0935 +member E0936 +member E0937 +member E0938 +member E0939 +member E093A +member E093B +member E093C +member E093D +member E093E +member E093F +member E0940 +member E0941 +member E0942 +member E0943 +member E0944 +member E0945 +member E0946 +member E0947 +member E0948 +member E0949 +member E094A +member E094B +member E094C +member E094D +member E094E +member E094F +member E0950 +member E0951 +member E0952 +member E0953 +member E0954 +member E0955 +member E0956 +member E0957 +member E0958 +member E0959 +member E095A +member E095B +member E095C +member E095D +member E095E +member E095F +member E0960 +member E0961 +member E0962 +member E0963 +member E0964 +member E0965 +member E0966 +member E0967 +member E0968 +member E0969 +member E096A +member E096B +member E096C +member E096D +member E096E +member E096F +member E0970 +member E0971 +member E0972 +member E0973 +member E0974 +member E0975 +member E0976 +member E0977 +member E0978 +member E0979 +member E097A +member E097B +member E097C +member E097D +member E097E +member E097F +member E0980 +member E0981 +member E0982 +member E0983 +member E0984 +member E0985 +member E0986 +member E0987 +member E0988 +member E0989 +member E098A +member E098B +member E098C +member E098D +member E098E +member E098F +member E0990 +member E0991 +member E0992 +member E0993 +member E0994 +member E0995 +member E0996 +member E0997 +member E0998 +member E0999 +member E099A +member E099B +member E099C +member E099D +member E099E +member E099F +member E09A0 +member E09A1 +member E09A2 +member E09A3 +member E09A4 +member E09A5 +member E09A6 +member E09A7 +member E09A8 +member E09A9 +member E09AA +member E09AB +member E09AC +member E09AD +member E09AE +member E09AF +member E09B0 +member E09B1 +member E09B2 +member E09B3 +member E09B4 +member E09B5 +member E09B6 +member E09B7 +member E09B8 +member E09B9 +member E09BA +member E09BB +member E09BC +member E09BD +member E09BE +member E09BF +member E09C0 +member E09C1 +member E09C2 +member E09C3 +member E09C4 +member E09C5 +member E09C6 +member E09C7 +member E09C8 +member E09C9 +member E09CA +member E09CB +member E09CC +member E09CD +member E09CE +member E09CF +member E09D0 +member E09D1 +member E09D2 +member E09D3 +member E09D4 +member E09D5 +member E09D6 +member E09D7 +member E09D8 +member E09D9 +member E09DA +member E09DB +member E09DC +member E09DD +member E09DE +member E09DF +member E09E0 +member E09E1 +member E09E2 +member E09E3 +member E09E4 +member E09E5 +member E09E6 +member E09E7 +member E09E8 +member E09E9 +member E09EA +member E09EB +member E09EC +member E09ED +member E09EE +member E09EF +member E09F0 +member E09F1 +member E09F2 +member E09F3 +member E09F4 +member E09F5 +member E09F6 +member E09F7 +member E09F8 +member E09F9 +member E09FA +member E09FB +member E09FC +member E09FD +member E09FE +member E09FF +member E0A00 +member E0A01 +member E0A02 +member E0A03 +member E0A04 +member E0A05 +member E0A06 +member E0A07 +member E0A08 +member E0A09 +member E0A0A +member E0A0B +member E0A0C +member E0A0D +member E0A0E +member E0A0F +member E0A10 +member E0A11 +member E0A12 +member E0A13 +member E0A14 +member E0A15 +member E0A16 +member E0A17 +member E0A18 +member E0A19 +member E0A1A +member E0A1B +member E0A1C +member E0A1D +member E0A1E +member E0A1F +member E0A20 +member E0A21 +member E0A22 +member E0A23 +member E0A24 +member E0A25 +member E0A26 +member E0A27 +member E0A28 +member E0A29 +member E0A2A +member E0A2B +member E0A2C +member E0A2D +member E0A2E +member E0A2F +member E0A30 +member E0A31 +member E0A32 +member E0A33 +member E0A34 +member E0A35 +member E0A36 +member E0A37 +member E0A38 +member E0A39 +member E0A3A +member E0A3B +member E0A3C +member E0A3D +member E0A3E +member E0A3F +member E0A40 +member E0A41 +member E0A42 +member E0A43 +member E0A44 +member E0A45 +member E0A46 +member E0A47 +member E0A48 +member E0A49 +member E0A4A +member E0A4B +member E0A4C +member E0A4D +member E0A4E +member E0A4F +member E0A50 +member E0A51 +member E0A52 +member E0A53 +member E0A54 +member E0A55 +member E0A56 +member E0A57 +member E0A58 +member E0A59 +member E0A5A +member E0A5B +member E0A5C +member E0A5D +member E0A5E +member E0A5F +member E0A60 +member E0A61 +member E0A62 +member E0A63 +member E0A64 +member E0A65 +member E0A66 +member E0A67 +member E0A68 +member E0A69 +member E0A6A +member E0A6B +member E0A6C +member E0A6D +member E0A6E +member E0A6F +member E0A70 +member E0A71 +member E0A72 +member E0A73 +member E0A74 +member E0A75 +member E0A76 +member E0A77 +member E0A78 +member E0A79 +member E0A7A +member E0A7B +member E0A7C +member E0A7D +member E0A7E +member E0A7F +member E0A80 +member E0A81 +member E0A82 +member E0A83 +member E0A84 +member E0A85 +member E0A86 +member E0A87 +member E0A88 +member E0A89 +member E0A8A +member E0A8B +member E0A8C +member E0A8D +member E0A8E +member E0A8F +member E0A90 +member E0A91 +member E0A92 +member E0A93 +member E0A94 +member E0A95 +member E0A96 +member E0A97 +member E0A98 +member E0A99 +member E0A9A +member E0A9B +member E0A9C +member E0A9D +member E0A9E +member E0A9F +member E0AA0 +member E0AA1 +member E0AA2 +member E0AA3 +member E0AA4 +member E0AA5 +member E0AA6 +member E0AA7 +member E0AA8 +member E0AA9 +member E0AAA +member E0AAB +member E0AAC +member E0AAD +member E0AAE +member E0AAF +member E0AB0 +member E0AB1 +member E0AB2 +member E0AB3 +member E0AB4 +member E0AB5 +member E0AB6 +member E0AB7 +member E0AB8 +member E0AB9 +member E0ABA +member E0ABB +member E0ABC +member E0ABD +member E0ABE +member E0ABF +member E0AC0 +member E0AC1 +member E0AC2 +member E0AC3 +member E0AC4 +member E0AC5 +member E0AC6 +member E0AC7 +member E0AC8 +member E0AC9 +member E0ACA +member E0ACB +member E0ACC +member E0ACD +member E0ACE +member E0ACF +member E0AD0 +member E0AD1 +member E0AD2 +member E0AD3 +member E0AD4 +member E0AD5 +member E0AD6 +member E0AD7 +member E0AD8 +member E0AD9 +member E0ADA +member E0ADB +member E0ADC +member E0ADD +member E0ADE +member E0ADF +member E0AE0 +member E0AE1 +member E0AE2 +member E0AE3 +member E0AE4 +member E0AE5 +member E0AE6 +member E0AE7 +member E0AE8 +member E0AE9 +member E0AEA +member E0AEB +member E0AEC +member E0AED +member E0AEE +member E0AEF +member E0AF0 +member E0AF1 +member E0AF2 +member E0AF3 +member E0AF4 +member E0AF5 +member E0AF6 +member E0AF7 +member E0AF8 +member E0AF9 +member E0AFA +member E0AFB +member E0AFC +member E0AFD +member E0AFE +member E0AFF +member E0B00 +member E0B01 +member E0B02 +member E0B03 +member E0B04 +member E0B05 +member E0B06 +member E0B07 +member E0B08 +member E0B09 +member E0B0A +member E0B0B +member E0B0C +member E0B0D +member E0B0E +member E0B0F +member E0B10 +member E0B11 +member E0B12 +member E0B13 +member E0B14 +member E0B15 +member E0B16 +member E0B17 +member E0B18 +member E0B19 +member E0B1A +member E0B1B +member E0B1C +member E0B1D +member E0B1E +member E0B1F +member E0B20 +member E0B21 +member E0B22 +member E0B23 +member E0B24 +member E0B25 +member E0B26 +member E0B27 +member E0B28 +member E0B29 +member E0B2A +member E0B2B +member E0B2C +member E0B2D +member E0B2E +member E0B2F +member E0B30 +member E0B31 +member E0B32 +member E0B33 +member E0B34 +member E0B35 +member E0B36 +member E0B37 +member E0B38 +member E0B39 +member E0B3A +member E0B3B +member E0B3C +member E0B3D +member E0B3E +member E0B3F +member E0B40 +member E0B41 +member E0B42 +member E0B43 +member E0B44 +member E0B45 +member E0B46 +member E0B47 +member E0B48 +member E0B49 +member E0B4A +member E0B4B +member E0B4C +member E0B4D +member E0B4E +member E0B4F +member E0B50 +member E0B51 +member E0B52 +member E0B53 +member E0B54 +member E0B55 +member E0B56 +member E0B57 +member E0B58 +member E0B59 +member E0B5A +member E0B5B +member E0B5C +member E0B5D +member E0B5E +member E0B5F +member E0B60 +member E0B61 +member E0B62 +member E0B63 +member E0B64 +member E0B65 +member E0B66 +member E0B67 +member E0B68 +member E0B69 +member E0B6A +member E0B6B +member E0B6C +member E0B6D +member E0B6E +member E0B6F +member E0B70 +member E0B71 +member E0B72 +member E0B73 +member E0B74 +member E0B75 +member E0B76 +member E0B77 +member E0B78 +member E0B79 +member E0B7A +member E0B7B +member E0B7C +member E0B7D +member E0B7E +member E0B7F +member E0B80 +member E0B81 +member E0B82 +member E0B83 +member E0B84 +member E0B85 +member E0B86 +member E0B87 +member E0B88 +member E0B89 +member E0B8A +member E0B8B +member E0B8C +member E0B8D +member E0B8E +member E0B8F +member E0B90 +member E0B91 +member E0B92 +member E0B93 +member E0B94 +member E0B95 +member E0B96 +member E0B97 +member E0B98 +member E0B99 +member E0B9A +member E0B9B +member E0B9C +member E0B9D +member E0B9E +member E0B9F +member E0BA0 +member E0BA1 +member E0BA2 +member E0BA3 +member E0BA4 +member E0BA5 +member E0BA6 +member E0BA7 +member E0BA8 +member E0BA9 +member E0BAA +member E0BAB +member E0BAC +member E0BAD +member E0BAE +member E0BAF +member E0BB0 +member E0BB1 +member E0BB2 +member E0BB3 +member E0BB4 +member E0BB5 +member E0BB6 +member E0BB7 +member E0BB8 +member E0BB9 +member E0BBA +member E0BBB +member E0BBC +member E0BBD +member E0BBE +member E0BBF +member E0BC0 +member E0BC1 +member E0BC2 +member E0BC3 +member E0BC4 +member E0BC5 +member E0BC6 +member E0BC7 +member E0BC8 +member E0BC9 +member E0BCA +member E0BCB +member E0BCC +member E0BCD +member E0BCE +member E0BCF +member E0BD0 +member E0BD1 +member E0BD2 +member E0BD3 +member E0BD4 +member E0BD5 +member E0BD6 +member E0BD7 +member E0BD8 +member E0BD9 +member E0BDA +member E0BDB +member E0BDC +member E0BDD +member E0BDE +member E0BDF +member E0BE0 +member E0BE1 +member E0BE2 +member E0BE3 +member E0BE4 +member E0BE5 +member E0BE6 +member E0BE7 +member E0BE8 +member E0BE9 +member E0BEA +member E0BEB +member E0BEC +member E0BED +member E0BEE +member E0BEF +member E0BF0 +member E0BF1 +member E0BF2 +member E0BF3 +member E0BF4 +member E0BF5 +member E0BF6 +member E0BF7 +member E0BF8 +member E0BF9 +member E0BFA +member E0BFB +member E0BFC +member E0BFD +member E0BFE +member E0BFF +member E0C00 +member E0C01 +member E0C02 +member E0C03 +member E0C04 +member E0C05 +member E0C06 +member E0C07 +member E0C08 +member E0C09 +member E0C0A +member E0C0B +member E0C0C +member E0C0D +member E0C0E +member E0C0F +member E0C10 +member E0C11 +member E0C12 +member E0C13 +member E0C14 +member E0C15 +member E0C16 +member E0C17 +member E0C18 +member E0C19 +member E0C1A +member E0C1B +member E0C1C +member E0C1D +member E0C1E +member E0C1F +member E0C20 +member E0C21 +member E0C22 +member E0C23 +member E0C24 +member E0C25 +member E0C26 +member E0C27 +member E0C28 +member E0C29 +member E0C2A +member E0C2B +member E0C2C +member E0C2D +member E0C2E +member E0C2F +member E0C30 +member E0C31 +member E0C32 +member E0C33 +member E0C34 +member E0C35 +member E0C36 +member E0C37 +member E0C38 +member E0C39 +member E0C3A +member E0C3B +member E0C3C +member E0C3D +member E0C3E +member E0C3F +member E0C40 +member E0C41 +member E0C42 +member E0C43 +member E0C44 +member E0C45 +member E0C46 +member E0C47 +member E0C48 +member E0C49 +member E0C4A +member E0C4B +member E0C4C +member E0C4D +member E0C4E +member E0C4F +member E0C50 +member E0C51 +member E0C52 +member E0C53 +member E0C54 +member E0C55 +member E0C56 +member E0C57 +member E0C58 +member E0C59 +member E0C5A +member E0C5B +member E0C5C +member E0C5D +member E0C5E +member E0C5F +member E0C60 +member E0C61 +member E0C62 +member E0C63 +member E0C64 +member E0C65 +member E0C66 +member E0C67 +member E0C68 +member E0C69 +member E0C6A +member E0C6B +member E0C6C +member E0C6D +member E0C6E +member E0C6F +member E0C70 +member E0C71 +member E0C72 +member E0C73 +member E0C74 +member E0C75 +member E0C76 +member E0C77 +member E0C78 +member E0C79 +member E0C7A +member E0C7B +member E0C7C +member E0C7D +member E0C7E +member E0C7F +member E0C80 +member E0C81 +member E0C82 +member E0C83 +member E0C84 +member E0C85 +member E0C86 +member E0C87 +member E0C88 +member E0C89 +member E0C8A +member E0C8B +member E0C8C +member E0C8D +member E0C8E +member E0C8F +member E0C90 +member E0C91 +member E0C92 +member E0C93 +member E0C94 +member E0C95 +member E0C96 +member E0C97 +member E0C98 +member E0C99 +member E0C9A +member E0C9B +member E0C9C +member E0C9D +member E0C9E +member E0C9F +member E0CA0 +member E0CA1 +member E0CA2 +member E0CA3 +member E0CA4 +member E0CA5 +member E0CA6 +member E0CA7 +member E0CA8 +member E0CA9 +member E0CAA +member E0CAB +member E0CAC +member E0CAD +member E0CAE +member E0CAF +member E0CB0 +member E0CB1 +member E0CB2 +member E0CB3 +member E0CB4 +member E0CB5 +member E0CB6 +member E0CB7 +member E0CB8 +member E0CB9 +member E0CBA +member E0CBB +member E0CBC +member E0CBD +member E0CBE +member E0CBF +member E0CC0 +member E0CC1 +member E0CC2 +member E0CC3 +member E0CC4 +member E0CC5 +member E0CC6 +member E0CC7 +member E0CC8 +member E0CC9 +member E0CCA +member E0CCB +member E0CCC +member E0CCD +member E0CCE +member E0CCF +member E0CD0 +member E0CD1 +member E0CD2 +member E0CD3 +member E0CD4 +member E0CD5 +member E0CD6 +member E0CD7 +member E0CD8 +member E0CD9 +member E0CDA +member E0CDB +member E0CDC +member E0CDD +member E0CDE +member E0CDF +member E0CE0 +member E0CE1 +member E0CE2 +member E0CE3 +member E0CE4 +member E0CE5 +member E0CE6 +member E0CE7 +member E0CE8 +member E0CE9 +member E0CEA +member E0CEB +member E0CEC +member E0CED +member E0CEE +member E0CEF +member E0CF0 +member E0CF1 +member E0CF2 +member E0CF3 +member E0CF4 +member E0CF5 +member E0CF6 +member E0CF7 +member E0CF8 +member E0CF9 +member E0CFA +member E0CFB +member E0CFC +member E0CFD +member E0CFE +member E0CFF +member E0D00 +member E0D01 +member E0D02 +member E0D03 +member E0D04 +member E0D05 +member E0D06 +member E0D07 +member E0D08 +member E0D09 +member E0D0A +member E0D0B +member E0D0C +member E0D0D +member E0D0E +member E0D0F +member E0D10 +member E0D11 +member E0D12 +member E0D13 +member E0D14 +member E0D15 +member E0D16 +member E0D17 +member E0D18 +member E0D19 +member E0D1A +member E0D1B +member E0D1C +member E0D1D +member E0D1E +member E0D1F +member E0D20 +member E0D21 +member E0D22 +member E0D23 +member E0D24 +member E0D25 +member E0D26 +member E0D27 +member E0D28 +member E0D29 +member E0D2A +member E0D2B +member E0D2C +member E0D2D +member E0D2E +member E0D2F +member E0D30 +member E0D31 +member E0D32 +member E0D33 +member E0D34 +member E0D35 +member E0D36 +member E0D37 +member E0D38 +member E0D39 +member E0D3A +member E0D3B +member E0D3C +member E0D3D +member E0D3E +member E0D3F +member E0D40 +member E0D41 +member E0D42 +member E0D43 +member E0D44 +member E0D45 +member E0D46 +member E0D47 +member E0D48 +member E0D49 +member E0D4A +member E0D4B +member E0D4C +member E0D4D +member E0D4E +member E0D4F +member E0D50 +member E0D51 +member E0D52 +member E0D53 +member E0D54 +member E0D55 +member E0D56 +member E0D57 +member E0D58 +member E0D59 +member E0D5A +member E0D5B +member E0D5C +member E0D5D +member E0D5E +member E0D5F +member E0D60 +member E0D61 +member E0D62 +member E0D63 +member E0D64 +member E0D65 +member E0D66 +member E0D67 +member E0D68 +member E0D69 +member E0D6A +member E0D6B +member E0D6C +member E0D6D +member E0D6E +member E0D6F +member E0D70 +member E0D71 +member E0D72 +member E0D73 +member E0D74 +member E0D75 +member E0D76 +member E0D77 +member E0D78 +member E0D79 +member E0D7A +member E0D7B +member E0D7C +member E0D7D +member E0D7E +member E0D7F +member E0D80 +member E0D81 +member E0D82 +member E0D83 +member E0D84 +member E0D85 +member E0D86 +member E0D87 +member E0D88 +member E0D89 +member E0D8A +member E0D8B +member E0D8C +member E0D8D +member E0D8E +member E0D8F +member E0D90 +member E0D91 +member E0D92 +member E0D93 +member E0D94 +member E0D95 +member E0D96 +member E0D97 +member E0D98 +member E0D99 +member E0D9A +member E0D9B +member E0D9C +member E0D9D +member E0D9E +member E0D9F +member E0DA0 +member E0DA1 +member E0DA2 +member E0DA3 +member E0DA4 +member E0DA5 +member E0DA6 +member E0DA7 +member E0DA8 +member E0DA9 +member E0DAA +member E0DAB +member E0DAC +member E0DAD +member E0DAE +member E0DAF +member E0DB0 +member E0DB1 +member E0DB2 +member E0DB3 +member E0DB4 +member E0DB5 +member E0DB6 +member E0DB7 +member E0DB8 +member E0DB9 +member E0DBA +member E0DBB +member E0DBC +member E0DBD +member E0DBE +member E0DBF +member E0DC0 +member E0DC1 +member E0DC2 +member E0DC3 +member E0DC4 +member E0DC5 +member E0DC6 +member E0DC7 +member E0DC8 +member E0DC9 +member E0DCA +member E0DCB +member E0DCC +member E0DCD +member E0DCE +member E0DCF +member E0DD0 +member E0DD1 +member E0DD2 +member E0DD3 +member E0DD4 +member E0DD5 +member E0DD6 +member E0DD7 +member E0DD8 +member E0DD9 +member E0DDA +member E0DDB +member E0DDC +member E0DDD +member E0DDE +member E0DDF +member E0DE0 +member E0DE1 +member E0DE2 +member E0DE3 +member E0DE4 +member E0DE5 +member E0DE6 +member E0DE7 +member E0DE8 +member E0DE9 +member E0DEA +member E0DEB +member E0DEC +member E0DED +member E0DEE +member E0DEF +member E0DF0 +member E0DF1 +member E0DF2 +member E0DF3 +member E0DF4 +member E0DF5 +member E0DF6 +member E0DF7 +member E0DF8 +member E0DF9 +member E0DFA +member E0DFB +member E0DFC +member E0DFD +member E0DFE +member E0DFF +member E0E00 +member E0E01 +member E0E02 +member E0E03 +member E0E04 +member E0E05 +member E0E06 +member E0E07 +member E0E08 +member E0E09 +member E0E0A +member E0E0B +member E0E0C +member E0E0D +member E0E0E +member E0E0F +member E0E10 +member E0E11 +member E0E12 +member E0E13 +member E0E14 +member E0E15 +member E0E16 +member E0E17 +member E0E18 +member E0E19 +member E0E1A +member E0E1B +member E0E1C +member E0E1D +member E0E1E +member E0E1F +member E0E20 +member E0E21 +member E0E22 +member E0E23 +member E0E24 +member E0E25 +member E0E26 +member E0E27 +member E0E28 +member E0E29 +member E0E2A +member E0E2B +member E0E2C +member E0E2D +member E0E2E +member E0E2F +member E0E30 +member E0E31 +member E0E32 +member E0E33 +member E0E34 +member E0E35 +member E0E36 +member E0E37 +member E0E38 +member E0E39 +member E0E3A +member E0E3B +member E0E3C +member E0E3D +member E0E3E +member E0E3F +member E0E40 +member E0E41 +member E0E42 +member E0E43 +member E0E44 +member E0E45 +member E0E46 +member E0E47 +member E0E48 +member E0E49 +member E0E4A +member E0E4B +member E0E4C +member E0E4D +member E0E4E +member E0E4F +member E0E50 +member E0E51 +member E0E52 +member E0E53 +member E0E54 +member E0E55 +member E0E56 +member E0E57 +member E0E58 +member E0E59 +member E0E5A +member E0E5B +member E0E5C +member E0E5D +member E0E5E +member E0E5F +member E0E60 +member E0E61 +member E0E62 +member E0E63 +member E0E64 +member E0E65 +member E0E66 +member E0E67 +member E0E68 +member E0E69 +member E0E6A +member E0E6B +member E0E6C +member E0E6D +member E0E6E +member E0E6F +member E0E70 +member E0E71 +member E0E72 +member E0E73 +member E0E74 +member E0E75 +member E0E76 +member E0E77 +member E0E78 +member E0E79 +member E0E7A +member E0E7B +member E0E7C +member E0E7D +member E0E7E +member E0E7F +member E0E80 +member E0E81 +member E0E82 +member E0E83 +member E0E84 +member E0E85 +member E0E86 +member E0E87 +member E0E88 +member E0E89 +member E0E8A +member E0E8B +member E0E8C +member E0E8D +member E0E8E +member E0E8F +member E0E90 +member E0E91 +member E0E92 +member E0E93 +member E0E94 +member E0E95 +member E0E96 +member E0E97 +member E0E98 +member E0E99 +member E0E9A +member E0E9B +member E0E9C +member E0E9D +member E0E9E +member E0E9F +member E0EA0 +member E0EA1 +member E0EA2 +member E0EA3 +member E0EA4 +member E0EA5 +member E0EA6 +member E0EA7 +member E0EA8 +member E0EA9 +member E0EAA +member E0EAB +member E0EAC +member E0EAD +member E0EAE +member E0EAF +member E0EB0 +member E0EB1 +member E0EB2 +member E0EB3 +member E0EB4 +member E0EB5 +member E0EB6 +member E0EB7 +member E0EB8 +member E0EB9 +member E0EBA +member E0EBB +member E0EBC +member E0EBD +member E0EBE +member E0EBF +member E0EC0 +member E0EC1 +member E0EC2 +member E0EC3 +member E0EC4 +member E0EC5 +member E0EC6 +member E0EC7 +member E0EC8 +member E0EC9 +member E0ECA +member E0ECB +member E0ECC +member E0ECD +member E0ECE +member E0ECF +member E0ED0 +member E0ED1 +member E0ED2 +member E0ED3 +member E0ED4 +member E0ED5 +member E0ED6 +member E0ED7 +member E0ED8 +member E0ED9 +member E0EDA +member E0EDB +member E0EDC +member E0EDD +member E0EDE +member E0EDF +member E0EE0 +member E0EE1 +member E0EE2 +member E0EE3 +member E0EE4 +member E0EE5 +member E0EE6 +member E0EE7 +member E0EE8 +member E0EE9 +member E0EEA +member E0EEB +member E0EEC +member E0EED +member E0EEE +member E0EEF +member E0EF0 +member E0EF1 +member E0EF2 +member E0EF3 +member E0EF4 +member E0EF5 +member E0EF6 +member E0EF7 +member E0EF8 +member E0EF9 +member E0EFA +member E0EFB +member E0EFC +member E0EFD +member E0EFE +member E0EFF +member E0F00 +member E0F01 +member E0F02 +member E0F03 +member E0F04 +member E0F05 +member E0F06 +member E0F07 +member E0F08 +member E0F09 +member E0F0A +member E0F0B +member E0F0C +member E0F0D +member E0F0E +member E0F0F +member E0F10 +member E0F11 +member E0F12 +member E0F13 +member E0F14 +member E0F15 +member E0F16 +member E0F17 +member E0F18 +member E0F19 +member E0F1A +member E0F1B +member E0F1C +member E0F1D +member E0F1E +member E0F1F +member E0F20 +member E0F21 +member E0F22 +member E0F23 +member E0F24 +member E0F25 +member E0F26 +member E0F27 +member E0F28 +member E0F29 +member E0F2A +member E0F2B +member E0F2C +member E0F2D +member E0F2E +member E0F2F +member E0F30 +member E0F31 +member E0F32 +member E0F33 +member E0F34 +member E0F35 +member E0F36 +member E0F37 +member E0F38 +member E0F39 +member E0F3A +member E0F3B +member E0F3C +member E0F3D +member E0F3E +member E0F3F +member E0F40 +member E0F41 +member E0F42 +member E0F43 +member E0F44 +member E0F45 +member E0F46 +member E0F47 +member E0F48 +member E0F49 +member E0F4A +member E0F4B +member E0F4C +member E0F4D +member E0F4E +member E0F4F +member E0F50 +member E0F51 +member E0F52 +member E0F53 +member E0F54 +member E0F55 +member E0F56 +member E0F57 +member E0F58 +member E0F59 +member E0F5A +member E0F5B +member E0F5C +member E0F5D +member E0F5E +member E0F5F +member E0F60 +member E0F61 +member E0F62 +member E0F63 +member E0F64 +member E0F65 +member E0F66 +member E0F67 +member E0F68 +member E0F69 +member E0F6A +member E0F6B +member E0F6C +member E0F6D +member E0F6E +member E0F6F +member E0F70 +member E0F71 +member E0F72 +member E0F73 +member E0F74 +member E0F75 +member E0F76 +member E0F77 +member E0F78 +member E0F79 +member E0F7A +member E0F7B +member E0F7C +member E0F7D +member E0F7E +member E0F7F +member E0F80 +member E0F81 +member E0F82 +member E0F83 +member E0F84 +member E0F85 +member E0F86 +member E0F87 +member E0F88 +member E0F89 +member E0F8A +member E0F8B +member E0F8C +member E0F8D +member E0F8E +member E0F8F +member E0F90 +member E0F91 +member E0F92 +member E0F93 +member E0F94 +member E0F95 +member E0F96 +member E0F97 +member E0F98 +member E0F99 +member E0F9A +member E0F9B +member E0F9C +member E0F9D +member E0F9E +member E0F9F +member E0FA0 +member E0FA1 +member E0FA2 +member E0FA3 +member E0FA4 +member E0FA5 +member E0FA6 +member E0FA7 +member E0FA8 +member E0FA9 +member E0FAA +member E0FAB +member E0FAC +member E0FAD +member E0FAE +member E0FAF +member E0FB0 +member E0FB1 +member E0FB2 +member E0FB3 +member E0FB4 +member E0FB5 +member E0FB6 +member E0FB7 +member E0FB8 +member E0FB9 +member E0FBA +member E0FBB +member E0FBC +member E0FBD +member E0FBE +member E0FBF +member E0FC0 +member E0FC1 +member E0FC2 +member E0FC3 +member E0FC4 +member E0FC5 +member E0FC6 +member E0FC7 +member E0FC8 +member E0FC9 +member E0FCA +member E0FCB +member E0FCC +member E0FCD +member E0FCE +member E0FCF +member E0FD0 +member E0FD1 +member E0FD2 +member E0FD3 +member E0FD4 +member E0FD5 +member E0FD6 +member E0FD7 +member E0FD8 +member E0FD9 +member E0FDA +member E0FDB +member E0FDC +member E0FDD +member E0FDE +member E0FDF +member E0FE0 +member E0FE1 +member E0FE2 +member E0FE3 +member E0FE4 +member E0FE5 +member E0FE6 +member E0FE7 +member E0FE8 +member E0FE9 +member E0FEA +member E0FEB +member E0FEC +member E0FED +member E0FEE +member E0FEF +member E0FF0 +member E0FF1 +member E0FF2 +member E0FF3 +member E0FF4 +member E0FF5 +member E0FF6 +member E0FF7 +member E0FF8 +member E0FF9 +member E0FFA +member E0FFB +member E0FFC +member E0FFD +member E0FFE +member E0FFF +nonmember 0000 +nonmember 0001 +nonmember 0002 +nonmember 0003 +nonmember 0004 +nonmember 0005 +nonmember 0006 +nonmember 0007 +nonmember 0008 +nonmember 0009 +nonmember 000A +nonmember 000B +nonmember 000C +nonmember 000D +nonmember 000E +nonmember 000F +nonmember 0010 +nonmember 0011 +nonmember 0012 +nonmember 0013 +nonmember 0014 +nonmember 0015 +nonmember 0016 +nonmember 0017 +nonmember 0018 +nonmember 0019 +nonmember 001A +nonmember 001B +nonmember 001C +nonmember 001D +nonmember 001E +nonmember 001F +nonmember 0020 +nonmember 0021 +nonmember 0022 +nonmember 0023 +nonmember 0024 +nonmember 0025 +nonmember 0026 +nonmember 0027 +nonmember 0028 +nonmember 0029 +nonmember 002A +nonmember 002B +nonmember 002C +nonmember 002D +nonmember 002E +nonmember 002F +nonmember 0030 +nonmember 0031 +nonmember 0032 +nonmember 0033 +nonmember 0034 +nonmember 0035 +nonmember 0036 +nonmember 0037 +nonmember 0038 +nonmember 0039 +nonmember 003A +nonmember 003B +nonmember 003C +nonmember 003D +nonmember 003E +nonmember 003F +nonmember 0040 +nonmember 0041 +nonmember 0042 +nonmember 0043 +nonmember 0044 +nonmember 0045 +nonmember 0046 +nonmember 0047 +nonmember 0048 +nonmember 0049 +nonmember 004A +nonmember 004B +nonmember 004C +nonmember 004D +nonmember 004E +nonmember 004F +nonmember 0050 +nonmember 0051 +nonmember 0052 +nonmember 0053 +nonmember 0054 +nonmember 0055 +nonmember 0056 +nonmember 0057 +nonmember 0058 +nonmember 0059 +nonmember 005A +nonmember 005B +nonmember 005C +nonmember 005D +nonmember 005E +nonmember 005F +nonmember 0060 +nonmember 0061 +nonmember 0062 +nonmember 0063 +nonmember 0064 +nonmember 0065 +nonmember 0066 +nonmember 0067 +nonmember 0068 +nonmember 0069 +nonmember 006A +nonmember 006B +nonmember 006C +nonmember 006D +nonmember 006E +nonmember 006F +nonmember 0070 +nonmember 0071 +nonmember 0072 +nonmember 0073 +nonmember 0074 +nonmember 0075 +nonmember 0076 +nonmember 0077 +nonmember 0078 +nonmember 0079 +nonmember 007A +nonmember 007B +nonmember 007C +nonmember 007D +nonmember 007E +nonmember 007F +nonmember 0084 +nonmember 0086 +nonmember 009F +nonmember 00A1 +nonmember 00AC +nonmember 00AE +nonmember 00B0 +nonmember 00D7 +nonmember 00E9 +nonmember 00FF +nonmember 0100 +nonmember 0131 +nonmember 0178 +nonmember 01C5 +nonmember 01C6 +nonmember 0300 +nonmember 0301 +nonmember 0308 +nonmember 0323 +nonmember 034E +nonmember 0350 +nonmember 0386 +nonmember 03A9 +nonmember 0400 +nonmember 0410 +nonmember 0439 +nonmember 04CF +nonmember 05D0 +nonmember 05EA +nonmember 05FF +nonmember 0606 +nonmember 0607 +nonmember 061B +nonmember 061D +nonmember 0627 +nonmember 0639 +nonmember 0644 +nonmember 06DC +nonmember 06DE +nonmember 070E +nonmember 0710 +nonmember 088F +nonmember 0892 +nonmember 08E1 +nonmember 08E3 +nonmember 0915 +nonmember 093E +nonmember 0E01 +nonmember 0E2A +nonmember 10A0 +nonmember 1100 +nonmember 115E +nonmember 1161 +nonmember 167F +nonmember 1681 +nonmember 17B3 +nonmember 17B6 +nonmember 180A +nonmember 1810 +nonmember 1FBC +nonmember 1FFF +nonmember 2010 +nonmember 2018 +nonmember 201C +nonmember 2026 +nonmember 2027 +nonmember 2030 +nonmember 203B +nonmember 2044 +nonmember 205E +nonmember 2070 +nonmember 20AC +nonmember 2116 +nonmember 2122 +nonmember 2190 +nonmember 21D2 +nonmember 2200 +nonmember 2260 +nonmember 2312 +nonmember 2500 +nonmember 2502 +nonmember 25A0 +nonmember 2600 +nonmember 2610 +nonmember 263A +nonmember 2665 +nonmember 2713 +nonmember 2764 +nonmember 2FFF +nonmember 3001 +nonmember 3002 +nonmember 300C +nonmember 3042 +nonmember 30A2 +nonmember 3163 +nonmember 3165 +nonmember 4E00 +nonmember 9FFF +nonmember AC00 +nonmember FDFF +nonmember FE10 +nonmember FE20 +nonmember FE30 +nonmember FE40 +nonmember FE50 +nonmember FE60 +nonmember FE70 +nonmember FEFE +nonmember FF00 +nonmember FF01 +nonmember FF08 +nonmember FF0C +nonmember FF1A +nonmember FF1B +nonmember FF3B +nonmember FF5B +nonmember FF9F +nonmember FFA1 +nonmember FFEF +nonmember FFFC +nonmember FFFD +nonmember 110BC +nonmember 110BE +nonmember 110CC +nonmember 110CE +nonmember 1342F +nonmember 13440 +nonmember 1BC9F +nonmember 1BCA4 +nonmember 1D172 +nonmember 1D17B +nonmember 1F600 +nonmember 1F680 +nonmember 1F6E0 +nonmember 1F9EA +nonmember DFFFF +nonmember E1000 +nonmember 10FFFD diff --git a/tests/fixtures/redaction-separator-corpus.txt b/tests/fixtures/redaction-separator-corpus.txt new file mode 100644 index 0000000..5f448df --- /dev/null +++ b/tests/fixtures/redaction-separator-corpus.txt @@ -0,0 +1,2312 @@ +# idutf8_hexexpected_redacted +# Generated shared differential corpus for TypeScript and Rust redaction. +api-key-U+00A0 617069c2a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+00AD 617069c2ad6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+034F 617069cd8f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+061C 617069d89c6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+115F 617069e1859f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+1160 617069e185a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+180E 617069e1a08e6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+200B 617069e2808b6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+200C 617069e2808c6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+200D 617069e2808d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+200E 617069e2808e6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+200F 617069e2808f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2028 617069e280a86b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202A 617069e280aa6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202B 617069e280ab6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202C 617069e280ac6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202D 617069e280ad6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202E 617069e280ae6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+202F 617069e280af6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2060 617069e281a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2065 617069e281a56b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2066 617069e281a66b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2067 617069e281a76b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2068 617069e281a86b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+2069 617069e281a96b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+3000 617069e380806b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+3164 617069e385a46b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+E0001 617069f3a080816b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+E0100 617069f3a084806b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FE0F 617069efb88f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FEFF 617069efbbbf6b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFA0 617069efbea06b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF0 617069efbfb06b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF1 617069efbfb16b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF2 617069efbfb26b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF3 617069efbfb36b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF4 617069efbfb46b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF5 617069efbfb56b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF6 617069efbfb66b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF7 617069efbfb76b65793a2053594e5448455449435f4f50415155455f313233343536 true +api-key-U+FFF8 617069efbfb86b65793a2053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+00A0 417574686f72697a6174696f6ec2a03a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+00AD 417574686f72697a6174696f6ec2ad3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+034F 417574686f72697a6174696f6ecd8f3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+061C 417574686f72697a6174696f6ed89c3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+115F 417574686f72697a6174696f6ee1859f3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+1160 417574686f72697a6174696f6ee185a03a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+180E 417574686f72697a6174696f6ee1a08e3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+200B 417574686f72697a6174696f6ee2808b3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+200C 417574686f72697a6174696f6ee2808c3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+200D 417574686f72697a6174696f6ee2808d3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+200E 417574686f72697a6174696f6ee2808e3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+200F 417574686f72697a6174696f6ee2808f3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2028 417574686f72697a6174696f6ee280a83a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202A 417574686f72697a6174696f6ee280aa3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202B 417574686f72697a6174696f6ee280ab3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202C 417574686f72697a6174696f6ee280ac3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202D 417574686f72697a6174696f6ee280ad3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202E 417574686f72697a6174696f6ee280ae3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+202F 417574686f72697a6174696f6ee280af3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2060 417574686f72697a6174696f6ee281a03a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2065 417574686f72697a6174696f6ee281a53a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2066 417574686f72697a6174696f6ee281a63a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2067 417574686f72697a6174696f6ee281a73a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2068 417574686f72697a6174696f6ee281a83a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+2069 417574686f72697a6174696f6ee281a93a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+3000 417574686f72697a6174696f6ee380803a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+3164 417574686f72697a6174696f6ee385a43a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+E0001 417574686f72697a6174696f6ef3a080813a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+E0100 417574686f72697a6174696f6ef3a084803a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FE0F 417574686f72697a6174696f6eefb88f3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FEFF 417574686f72697a6174696f6eefbbbf3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFA0 417574686f72697a6174696f6eefbea03a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF0 417574686f72697a6174696f6eefbfb03a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF1 417574686f72697a6174696f6eefbfb13a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF2 417574686f72697a6174696f6eefbfb23a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF3 417574686f72697a6174696f6eefbfb33a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF4 417574686f72697a6174696f6eefbfb43a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF5 417574686f72697a6174696f6eefbfb53a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF6 417574686f72697a6174696f6eefbfb63a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF7 417574686f72697a6174696f6eefbfb73a204265617265722053594e5448455449435f4f50415155455f313233343536 true +authorization-end-U+FFF8 417574686f72697a6174696f6eefbfb83a204265617265722053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+00A0 417574686f72697a6174696f6e3a20426561726572c2a053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+00AD 417574686f72697a6174696f6e3a20426561726572c2ad53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+034F 417574686f72697a6174696f6e3a20426561726572cd8f53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+061C 417574686f72697a6174696f6e3a20426561726572d89c53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+115F 417574686f72697a6174696f6e3a20426561726572e1859f53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+1160 417574686f72697a6174696f6e3a20426561726572e185a053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+180E 417574686f72697a6174696f6e3a20426561726572e1a08e53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+200B 417574686f72697a6174696f6e3a20426561726572e2808b53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+200C 417574686f72697a6174696f6e3a20426561726572e2808c53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+200D 417574686f72697a6174696f6e3a20426561726572e2808d53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+200E 417574686f72697a6174696f6e3a20426561726572e2808e53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+200F 417574686f72697a6174696f6e3a20426561726572e2808f53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2028 417574686f72697a6174696f6e3a20426561726572e280a853594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202A 417574686f72697a6174696f6e3a20426561726572e280aa53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202B 417574686f72697a6174696f6e3a20426561726572e280ab53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202C 417574686f72697a6174696f6e3a20426561726572e280ac53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202D 417574686f72697a6174696f6e3a20426561726572e280ad53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202E 417574686f72697a6174696f6e3a20426561726572e280ae53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+202F 417574686f72697a6174696f6e3a20426561726572e280af53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2060 417574686f72697a6174696f6e3a20426561726572e281a053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2065 417574686f72697a6174696f6e3a20426561726572e281a553594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2066 417574686f72697a6174696f6e3a20426561726572e281a653594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2067 417574686f72697a6174696f6e3a20426561726572e281a753594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2068 417574686f72697a6174696f6e3a20426561726572e281a853594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+2069 417574686f72697a6174696f6e3a20426561726572e281a953594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+3000 417574686f72697a6174696f6e3a20426561726572e3808053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+3164 417574686f72697a6174696f6e3a20426561726572e385a453594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+E0001 417574686f72697a6174696f6e3a20426561726572f3a0808153594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+E0100 417574686f72697a6174696f6e3a20426561726572f3a0848053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FE0F 417574686f72697a6174696f6e3a20426561726572efb88f53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FEFF 417574686f72697a6174696f6e3a20426561726572efbbbf53594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFA0 417574686f72697a6174696f6e3a20426561726572efbea053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF0 417574686f72697a6174696f6e3a20426561726572efbfb053594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF1 417574686f72697a6174696f6e3a20426561726572efbfb153594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF2 417574686f72697a6174696f6e3a20426561726572efbfb253594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF3 417574686f72697a6174696f6e3a20426561726572efbfb353594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF4 417574686f72697a6174696f6e3a20426561726572efbfb453594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF5 417574686f72697a6174696f6e3a20426561726572efbfb553594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF6 417574686f72697a6174696f6e3a20426561726572efbfb653594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF7 417574686f72697a6174696f6e3a20426561726572efbfb753594e5448455449435f4f50415155455f313233343536 true +bearer-end-U+FFF8 417574686f72697a6174696f6e3a20426561726572efbfb853594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+00A0 426561726572c2a053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+00AD 426561726572c2ad53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+034F 426561726572cd8f53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+061C 426561726572d89c53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+115F 426561726572e1859f53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+1160 426561726572e185a053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+180E 426561726572e1a08e53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+200B 426561726572e2808b53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+200C 426561726572e2808c53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+200D 426561726572e2808d53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+200E 426561726572e2808e53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+200F 426561726572e2808f53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2028 426561726572e280a853594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202A 426561726572e280aa53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202B 426561726572e280ab53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202C 426561726572e280ac53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202D 426561726572e280ad53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202E 426561726572e280ae53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+202F 426561726572e280af53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2060 426561726572e281a053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2065 426561726572e281a553594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2066 426561726572e281a653594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2067 426561726572e281a753594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2068 426561726572e281a853594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+2069 426561726572e281a953594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+3000 426561726572e3808053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+3164 426561726572e385a453594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+E0001 426561726572f3a0808153594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+E0100 426561726572f3a0848053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FE0F 426561726572efb88f53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FEFF 426561726572efbbbf53594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFA0 426561726572efbea053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF0 426561726572efbfb053594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF1 426561726572efbfb153594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF2 426561726572efbfb253594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF3 426561726572efbfb353594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF4 426561726572efbfb453594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF5 426561726572efbfb553594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF6 426561726572efbfb653594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF7 426561726572efbfb753594e5448455449435f4f50415155455f313233343536 true +bearer-joined-U+FFF8 426561726572efbfb853594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+00A0 417574686f72697a6174696f6e3a20426561c2a07265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+00AD 417574686f72697a6174696f6e3a20426561c2ad7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+034F 417574686f72697a6174696f6e3a20426561cd8f7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+061C 417574686f72697a6174696f6e3a20426561d89c7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+115F 417574686f72697a6174696f6e3a20426561e1859f7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+1160 417574686f72697a6174696f6e3a20426561e185a07265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+180E 417574686f72697a6174696f6e3a20426561e1a08e7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+200B 417574686f72697a6174696f6e3a20426561e2808b7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+200C 417574686f72697a6174696f6e3a20426561e2808c7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+200D 417574686f72697a6174696f6e3a20426561e2808d7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+200E 417574686f72697a6174696f6e3a20426561e2808e7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+200F 417574686f72697a6174696f6e3a20426561e2808f7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2028 417574686f72697a6174696f6e3a20426561e280a87265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202A 417574686f72697a6174696f6e3a20426561e280aa7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202B 417574686f72697a6174696f6e3a20426561e280ab7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202C 417574686f72697a6174696f6e3a20426561e280ac7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202D 417574686f72697a6174696f6e3a20426561e280ad7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202E 417574686f72697a6174696f6e3a20426561e280ae7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+202F 417574686f72697a6174696f6e3a20426561e280af7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2060 417574686f72697a6174696f6e3a20426561e281a07265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2065 417574686f72697a6174696f6e3a20426561e281a57265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2066 417574686f72697a6174696f6e3a20426561e281a67265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2067 417574686f72697a6174696f6e3a20426561e281a77265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2068 417574686f72697a6174696f6e3a20426561e281a87265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+2069 417574686f72697a6174696f6e3a20426561e281a97265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+3000 417574686f72697a6174696f6e3a20426561e380807265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+3164 417574686f72697a6174696f6e3a20426561e385a47265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+E0001 417574686f72697a6174696f6e3a20426561f3a080817265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+E0100 417574686f72697a6174696f6e3a20426561f3a084807265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FE0F 417574686f72697a6174696f6e3a20426561efb88f7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FEFF 417574686f72697a6174696f6e3a20426561efbbbf7265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFA0 417574686f72697a6174696f6e3a20426561efbea07265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF0 417574686f72697a6174696f6e3a20426561efbfb07265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF1 417574686f72697a6174696f6e3a20426561efbfb17265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF2 417574686f72697a6174696f6e3a20426561efbfb27265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF3 417574686f72697a6174696f6e3a20426561efbfb37265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF4 417574686f72697a6174696f6e3a20426561efbfb47265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF5 417574686f72697a6174696f6e3a20426561efbfb57265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF6 417574686f72697a6174696f6e3a20426561efbfb67265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF7 417574686f72697a6174696f6e3a20426561efbfb77265722053594e5448455449435f4f50415155455f313233343536 true +bearer-middle-U+FFF8 417574686f72697a6174696f6e3a20426561efbfb87265722053594e5448455449435f4f50415155455f313233343536 true +bearer-value-U+00A0 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536c2a07461696c true +bearer-value-U+00AD 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536c2ad7461696c true +bearer-value-U+034F 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536cd8f7461696c true +bearer-value-U+061C 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536d89c7461696c true +bearer-value-U+115F 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e1859f7461696c true +bearer-value-U+1160 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e185a07461696c true +bearer-value-U+180E 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e1a08e7461696c true +bearer-value-U+200B 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e2808b7461696c true +bearer-value-U+200C 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e2808c7461696c true +bearer-value-U+200D 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e2808d7461696c true +bearer-value-U+200E 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e2808e7461696c true +bearer-value-U+200F 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e2808f7461696c true +bearer-value-U+2028 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280a87461696c true +bearer-value-U+202A 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280aa7461696c true +bearer-value-U+202B 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280ab7461696c true +bearer-value-U+202C 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280ac7461696c true +bearer-value-U+202D 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280ad7461696c true +bearer-value-U+202E 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280ae7461696c true +bearer-value-U+202F 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e280af7461696c true +bearer-value-U+2060 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a07461696c true +bearer-value-U+2065 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a57461696c true +bearer-value-U+2066 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a67461696c true +bearer-value-U+2067 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a77461696c true +bearer-value-U+2068 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a87461696c true +bearer-value-U+2069 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e281a97461696c true +bearer-value-U+3000 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e380807461696c true +bearer-value-U+3164 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536e385a47461696c true +bearer-value-U+E0001 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536f3a080817461696c true +bearer-value-U+E0100 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536f3a084807461696c true +bearer-value-U+FE0F 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efb88f7461696c true +bearer-value-U+FEFF 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbbbf7461696c true +bearer-value-U+FFA0 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbea07461696c true +bearer-value-U+FFF0 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb07461696c true +bearer-value-U+FFF1 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb17461696c true +bearer-value-U+FFF2 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb27461696c true +bearer-value-U+FFF3 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb37461696c true +bearer-value-U+FFF4 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb47461696c true +bearer-value-U+FFF5 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb57461696c true +bearer-value-U+FFF6 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb67461696c true +bearer-value-U+FFF7 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb77461696c true +bearer-value-U+FFF8 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536efbfb87461696c true +benign-authorizing-U+00A0 617574686f72697a6174696f6ec2a0696e673a206e6f7465 false +benign-authorizing-U+00AD 617574686f72697a6174696f6ec2ad696e673a206e6f7465 false +benign-authorizing-U+034F 617574686f72697a6174696f6ecd8f696e673a206e6f7465 false +benign-authorizing-U+061C 617574686f72697a6174696f6ed89c696e673a206e6f7465 false +benign-authorizing-U+115F 617574686f72697a6174696f6ee1859f696e673a206e6f7465 false +benign-authorizing-U+1160 617574686f72697a6174696f6ee185a0696e673a206e6f7465 false +benign-authorizing-U+180E 617574686f72697a6174696f6ee1a08e696e673a206e6f7465 false +benign-authorizing-U+200B 617574686f72697a6174696f6ee2808b696e673a206e6f7465 false +benign-authorizing-U+200C 617574686f72697a6174696f6ee2808c696e673a206e6f7465 false +benign-authorizing-U+200D 617574686f72697a6174696f6ee2808d696e673a206e6f7465 false +benign-authorizing-U+200E 617574686f72697a6174696f6ee2808e696e673a206e6f7465 false +benign-authorizing-U+200F 617574686f72697a6174696f6ee2808f696e673a206e6f7465 false +benign-authorizing-U+2028 617574686f72697a6174696f6ee280a8696e673a206e6f7465 false +benign-authorizing-U+202A 617574686f72697a6174696f6ee280aa696e673a206e6f7465 false +benign-authorizing-U+202B 617574686f72697a6174696f6ee280ab696e673a206e6f7465 false +benign-authorizing-U+202C 617574686f72697a6174696f6ee280ac696e673a206e6f7465 false +benign-authorizing-U+202D 617574686f72697a6174696f6ee280ad696e673a206e6f7465 false +benign-authorizing-U+202E 617574686f72697a6174696f6ee280ae696e673a206e6f7465 false +benign-authorizing-U+202F 617574686f72697a6174696f6ee280af696e673a206e6f7465 false +benign-authorizing-U+2060 617574686f72697a6174696f6ee281a0696e673a206e6f7465 false +benign-authorizing-U+2065 617574686f72697a6174696f6ee281a5696e673a206e6f7465 false +benign-authorizing-U+2066 617574686f72697a6174696f6ee281a6696e673a206e6f7465 false +benign-authorizing-U+2067 617574686f72697a6174696f6ee281a7696e673a206e6f7465 false +benign-authorizing-U+2068 617574686f72697a6174696f6ee281a8696e673a206e6f7465 false +benign-authorizing-U+2069 617574686f72697a6174696f6ee281a9696e673a206e6f7465 false +benign-authorizing-U+3000 617574686f72697a6174696f6ee38080696e673a206e6f7465 false +benign-authorizing-U+3164 617574686f72697a6174696f6ee385a4696e673a206e6f7465 false +benign-authorizing-U+E0001 617574686f72697a6174696f6ef3a08081696e673a206e6f7465 false +benign-authorizing-U+E0100 617574686f72697a6174696f6ef3a08480696e673a206e6f7465 false +benign-authorizing-U+FE0F 617574686f72697a6174696f6eefb88f696e673a206e6f7465 false +benign-authorizing-U+FEFF 617574686f72697a6174696f6eefbbbf696e673a206e6f7465 false +benign-authorizing-U+FFA0 617574686f72697a6174696f6eefbea0696e673a206e6f7465 false +benign-authorizing-U+FFF0 617574686f72697a6174696f6eefbfb0696e673a206e6f7465 false +benign-authorizing-U+FFF1 617574686f72697a6174696f6eefbfb1696e673a206e6f7465 false +benign-authorizing-U+FFF2 617574686f72697a6174696f6eefbfb2696e673a206e6f7465 false +benign-authorizing-U+FFF3 617574686f72697a6174696f6eefbfb3696e673a206e6f7465 false +benign-authorizing-U+FFF4 617574686f72697a6174696f6eefbfb4696e673a206e6f7465 false +benign-authorizing-U+FFF5 617574686f72697a6174696f6eefbfb5696e673a206e6f7465 false +benign-authorizing-U+FFF6 617574686f72697a6174696f6eefbfb6696e673a206e6f7465 false +benign-authorizing-U+FFF7 617574686f72697a6174696f6eefbfb7696e673a206e6f7465 false +benign-authorizing-U+FFF8 617574686f72697a6174696f6eefbfb8696e673a206e6f7465 false +benign-bearerish-U+00A0 626561726572697368c2a06e6f7465 false +benign-bearerish-U+00AD 626561726572697368c2ad6e6f7465 false +benign-bearerish-U+034F 626561726572697368cd8f6e6f7465 false +benign-bearerish-U+061C 626561726572697368d89c6e6f7465 false +benign-bearerish-U+115F 626561726572697368e1859f6e6f7465 false +benign-bearerish-U+1160 626561726572697368e185a06e6f7465 false +benign-bearerish-U+180E 626561726572697368e1a08e6e6f7465 false +benign-bearerish-U+200B 626561726572697368e2808b6e6f7465 false +benign-bearerish-U+200C 626561726572697368e2808c6e6f7465 false +benign-bearerish-U+200D 626561726572697368e2808d6e6f7465 false +benign-bearerish-U+200E 626561726572697368e2808e6e6f7465 false +benign-bearerish-U+200F 626561726572697368e2808f6e6f7465 false +benign-bearerish-U+2028 626561726572697368e280a86e6f7465 false +benign-bearerish-U+202A 626561726572697368e280aa6e6f7465 false +benign-bearerish-U+202B 626561726572697368e280ab6e6f7465 false +benign-bearerish-U+202C 626561726572697368e280ac6e6f7465 false +benign-bearerish-U+202D 626561726572697368e280ad6e6f7465 false +benign-bearerish-U+202E 626561726572697368e280ae6e6f7465 false +benign-bearerish-U+202F 626561726572697368e280af6e6f7465 false +benign-bearerish-U+2060 626561726572697368e281a06e6f7465 false +benign-bearerish-U+2065 626561726572697368e281a56e6f7465 false +benign-bearerish-U+2066 626561726572697368e281a66e6f7465 false +benign-bearerish-U+2067 626561726572697368e281a76e6f7465 false +benign-bearerish-U+2068 626561726572697368e281a86e6f7465 false +benign-bearerish-U+2069 626561726572697368e281a96e6f7465 false +benign-bearerish-U+3000 626561726572697368e380806e6f7465 false +benign-bearerish-U+3164 626561726572697368e385a46e6f7465 false +benign-bearerish-U+E0001 626561726572697368f3a080816e6f7465 false +benign-bearerish-U+E0100 626561726572697368f3a084806e6f7465 false +benign-bearerish-U+FE0F 626561726572697368efb88f6e6f7465 false +benign-bearerish-U+FEFF 626561726572697368efbbbf6e6f7465 false +benign-bearerish-U+FFA0 626561726572697368efbea06e6f7465 false +benign-bearerish-U+FFF0 626561726572697368efbfb06e6f7465 false +benign-bearerish-U+FFF1 626561726572697368efbfb16e6f7465 false +benign-bearerish-U+FFF2 626561726572697368efbfb26e6f7465 false +benign-bearerish-U+FFF3 626561726572697368efbfb36e6f7465 false +benign-bearerish-U+FFF4 626561726572697368efbfb46e6f7465 false +benign-bearerish-U+FFF5 626561726572697368efbfb56e6f7465 false +benign-bearerish-U+FFF6 626561726572697368efbfb66e6f7465 false +benign-bearerish-U+FFF7 626561726572697368efbfb76e6f7465 false +benign-bearerish-U+FFF8 626561726572697368efbfb86e6f7465 false +benign-prose-U+00A0 636166c2a0c3a920e4b896e7958c20c2a074657874 false +benign-prose-U+00AD 636166c2adc3a920e4b896e7958c20c2ad74657874 false +benign-prose-U+034F 636166cd8fc3a920e4b896e7958c20cd8f74657874 false +benign-prose-U+061C 636166d89cc3a920e4b896e7958c20d89c74657874 false +benign-prose-U+115F 636166e1859fc3a920e4b896e7958c20e1859f74657874 false +benign-prose-U+1160 636166e185a0c3a920e4b896e7958c20e185a074657874 false +benign-prose-U+180E 636166e1a08ec3a920e4b896e7958c20e1a08e74657874 false +benign-prose-U+200B 636166e2808bc3a920e4b896e7958c20e2808b74657874 false +benign-prose-U+200C 636166e2808cc3a920e4b896e7958c20e2808c74657874 false +benign-prose-U+200D 636166e2808dc3a920e4b896e7958c20e2808d74657874 false +benign-prose-U+200E 636166e2808ec3a920e4b896e7958c20e2808e74657874 false +benign-prose-U+200F 636166e2808fc3a920e4b896e7958c20e2808f74657874 false +benign-prose-U+2028 636166e280a8c3a920e4b896e7958c20e280a874657874 false +benign-prose-U+202A 636166e280aac3a920e4b896e7958c20e280aa74657874 false +benign-prose-U+202B 636166e280abc3a920e4b896e7958c20e280ab74657874 false +benign-prose-U+202C 636166e280acc3a920e4b896e7958c20e280ac74657874 false +benign-prose-U+202D 636166e280adc3a920e4b896e7958c20e280ad74657874 false +benign-prose-U+202E 636166e280aec3a920e4b896e7958c20e280ae74657874 false +benign-prose-U+202F 636166e280afc3a920e4b896e7958c20e280af74657874 false +benign-prose-U+2060 636166e281a0c3a920e4b896e7958c20e281a074657874 false +benign-prose-U+2065 636166e281a5c3a920e4b896e7958c20e281a574657874 false +benign-prose-U+2066 636166e281a6c3a920e4b896e7958c20e281a674657874 false +benign-prose-U+2067 636166e281a7c3a920e4b896e7958c20e281a774657874 false +benign-prose-U+2068 636166e281a8c3a920e4b896e7958c20e281a874657874 false +benign-prose-U+2069 636166e281a9c3a920e4b896e7958c20e281a974657874 false +benign-prose-U+3000 636166e38080c3a920e4b896e7958c20e3808074657874 false +benign-prose-U+3164 636166e385a4c3a920e4b896e7958c20e385a474657874 false +benign-prose-U+E0001 636166f3a08081c3a920e4b896e7958c20f3a0808174657874 false +benign-prose-U+E0100 636166f3a08480c3a920e4b896e7958c20f3a0848074657874 false +benign-prose-U+FE0F 636166efb88fc3a920e4b896e7958c20efb88f74657874 false +benign-prose-U+FEFF 636166efbbbfc3a920e4b896e7958c20efbbbf74657874 false +benign-prose-U+FFA0 636166efbea0c3a920e4b896e7958c20efbea074657874 false +benign-prose-U+FFF0 636166efbfb0c3a920e4b896e7958c20efbfb074657874 false +benign-prose-U+FFF1 636166efbfb1c3a920e4b896e7958c20efbfb174657874 false +benign-prose-U+FFF2 636166efbfb2c3a920e4b896e7958c20efbfb274657874 false +benign-prose-U+FFF3 636166efbfb3c3a920e4b896e7958c20efbfb374657874 false +benign-prose-U+FFF4 636166efbfb4c3a920e4b896e7958c20efbfb474657874 false +benign-prose-U+FFF5 636166efbfb5c3a920e4b896e7958c20efbfb574657874 false +benign-prose-U+FFF6 636166efbfb6c3a920e4b896e7958c20efbfb674657874 false +benign-prose-U+FFF7 636166efbfb7c3a920e4b896e7958c20efbfb774657874 false +benign-prose-U+FFF8 636166efbfb8c3a920e4b896e7958c20efbfb874657874 false +benign-tokenizer-U+00A0 6d79746f6b656ec2a0697a65723a206e6f7465 false +benign-tokenizer-U+00AD 6d79746f6b656ec2ad697a65723a206e6f7465 false +benign-tokenizer-U+034F 6d79746f6b656ecd8f697a65723a206e6f7465 false +benign-tokenizer-U+061C 6d79746f6b656ed89c697a65723a206e6f7465 false +benign-tokenizer-U+115F 6d79746f6b656ee1859f697a65723a206e6f7465 false +benign-tokenizer-U+1160 6d79746f6b656ee185a0697a65723a206e6f7465 false +benign-tokenizer-U+180E 6d79746f6b656ee1a08e697a65723a206e6f7465 false +benign-tokenizer-U+200B 6d79746f6b656ee2808b697a65723a206e6f7465 false +benign-tokenizer-U+200C 6d79746f6b656ee2808c697a65723a206e6f7465 false +benign-tokenizer-U+200D 6d79746f6b656ee2808d697a65723a206e6f7465 false +benign-tokenizer-U+200E 6d79746f6b656ee2808e697a65723a206e6f7465 false +benign-tokenizer-U+200F 6d79746f6b656ee2808f697a65723a206e6f7465 false +benign-tokenizer-U+2028 6d79746f6b656ee280a8697a65723a206e6f7465 false +benign-tokenizer-U+202A 6d79746f6b656ee280aa697a65723a206e6f7465 false +benign-tokenizer-U+202B 6d79746f6b656ee280ab697a65723a206e6f7465 false +benign-tokenizer-U+202C 6d79746f6b656ee280ac697a65723a206e6f7465 false +benign-tokenizer-U+202D 6d79746f6b656ee280ad697a65723a206e6f7465 false +benign-tokenizer-U+202E 6d79746f6b656ee280ae697a65723a206e6f7465 false +benign-tokenizer-U+202F 6d79746f6b656ee280af697a65723a206e6f7465 false +benign-tokenizer-U+2060 6d79746f6b656ee281a0697a65723a206e6f7465 false +benign-tokenizer-U+2065 6d79746f6b656ee281a5697a65723a206e6f7465 false +benign-tokenizer-U+2066 6d79746f6b656ee281a6697a65723a206e6f7465 false +benign-tokenizer-U+2067 6d79746f6b656ee281a7697a65723a206e6f7465 false +benign-tokenizer-U+2068 6d79746f6b656ee281a8697a65723a206e6f7465 false +benign-tokenizer-U+2069 6d79746f6b656ee281a9697a65723a206e6f7465 false +benign-tokenizer-U+3000 6d79746f6b656ee38080697a65723a206e6f7465 false +benign-tokenizer-U+3164 6d79746f6b656ee385a4697a65723a206e6f7465 false +benign-tokenizer-U+E0001 6d79746f6b656ef3a08081697a65723a206e6f7465 false +benign-tokenizer-U+E0100 6d79746f6b656ef3a08480697a65723a206e6f7465 false +benign-tokenizer-U+FE0F 6d79746f6b656eefb88f697a65723a206e6f7465 false +benign-tokenizer-U+FEFF 6d79746f6b656eefbbbf697a65723a206e6f7465 false +benign-tokenizer-U+FFA0 6d79746f6b656eefbea0697a65723a206e6f7465 false +benign-tokenizer-U+FFF0 6d79746f6b656eefbfb0697a65723a206e6f7465 false +benign-tokenizer-U+FFF1 6d79746f6b656eefbfb1697a65723a206e6f7465 false +benign-tokenizer-U+FFF2 6d79746f6b656eefbfb2697a65723a206e6f7465 false +benign-tokenizer-U+FFF3 6d79746f6b656eefbfb3697a65723a206e6f7465 false +benign-tokenizer-U+FFF4 6d79746f6b656eefbfb4697a65723a206e6f7465 false +benign-tokenizer-U+FFF5 6d79746f6b656eefbfb5697a65723a206e6f7465 false +benign-tokenizer-U+FFF6 6d79746f6b656eefbfb6697a65723a206e6f7465 false +benign-tokenizer-U+FFF7 6d79746f6b656eefbfb7697a65723a206e6f7465 false +benign-tokenizer-U+FFF8 6d79746f6b656eefbfb8697a65723a206e6f7465 false +key-access_token-U+00A0 616363657373c2a05f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+00AD 616363657373c2ad5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+034F 616363657373cd8f5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+061C 616363657373d89c5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+115F 616363657373e1859f5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+1160 616363657373e185a05f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+180E 616363657373e1a08e5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+200B 616363657373e2808b5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+200C 616363657373e2808c5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+200D 616363657373e2808d5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+200E 616363657373e2808e5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+200F 616363657373e2808f5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2028 616363657373e280a85f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202A 616363657373e280aa5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202B 616363657373e280ab5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202C 616363657373e280ac5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202D 616363657373e280ad5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202E 616363657373e280ae5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+202F 616363657373e280af5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2060 616363657373e281a05f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2065 616363657373e281a55f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2066 616363657373e281a65f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2067 616363657373e281a75f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2068 616363657373e281a85f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+2069 616363657373e281a95f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+3000 616363657373e380805f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+3164 616363657373e385a45f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+E0001 616363657373f3a080815f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+E0100 616363657373f3a084805f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FE0F 616363657373efb88f5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FEFF 616363657373efbbbf5f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFA0 616363657373efbea05f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF0 616363657373efbfb05f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF1 616363657373efbfb15f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF2 616363657373efbfb25f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF3 616363657373efbfb35f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF4 616363657373efbfb45f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF5 616363657373efbfb55f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF6 616363657373efbfb65f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF7 616363657373efbfb75f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-access_token-U+FFF8 616363657373efbfb85f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+00A0 617069c2a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+00AD 617069c2ad2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+034F 617069cd8f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+061C 617069d89c2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+115F 617069e1859f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+1160 617069e185a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+180E 617069e1a08e2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+200B 617069e2808b2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+200C 617069e2808c2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+200D 617069e2808d2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+200E 617069e2808e2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+200F 617069e2808f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2028 617069e280a82d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202A 617069e280aa2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202B 617069e280ab2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202C 617069e280ac2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202D 617069e280ad2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202E 617069e280ae2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+202F 617069e280af2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2060 617069e281a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2065 617069e281a52d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2066 617069e281a62d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2067 617069e281a72d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2068 617069e281a82d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+2069 617069e281a92d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+3000 617069e380802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+3164 617069e385a42d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+E0001 617069f3a080812d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+E0100 617069f3a084802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FE0F 617069efb88f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FEFF 617069efbbbf2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFA0 617069efbea02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF0 617069efbfb02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF1 617069efbfb12d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF2 617069efbfb22d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF3 617069efbfb32d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF4 617069efbfb42d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF5 617069efbfb52d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF6 617069efbfb62d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF7 617069efbfb72d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api-key-U+FFF8 617069efbfb82d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+00A0 617069c2a05f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+00AD 617069c2ad5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+034F 617069cd8f5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+061C 617069d89c5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+115F 617069e1859f5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+1160 617069e185a05f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+180E 617069e1a08e5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+200B 617069e2808b5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+200C 617069e2808c5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+200D 617069e2808d5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+200E 617069e2808e5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+200F 617069e2808f5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2028 617069e280a85f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202A 617069e280aa5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202B 617069e280ab5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202C 617069e280ac5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202D 617069e280ad5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202E 617069e280ae5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+202F 617069e280af5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2060 617069e281a05f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2065 617069e281a55f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2066 617069e281a65f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2067 617069e281a75f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2068 617069e281a85f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+2069 617069e281a95f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+3000 617069e380805f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+3164 617069e385a45f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+E0001 617069f3a080815f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+E0100 617069f3a084805f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FE0F 617069efb88f5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FEFF 617069efbbbf5f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFA0 617069efbea05f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF0 617069efbfb05f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF1 617069efbfb15f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF2 617069efbfb25f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF3 617069efbfb35f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF4 617069efbfb45f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF5 617069efbfb55f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF6 617069efbfb65f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF7 617069efbfb75f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-api_key-U+FFF8 617069efbfb85f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+00A0 617069c2a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+00AD 617069c2ad6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+034F 617069cd8f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+061C 617069d89c6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+115F 617069e1859f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+1160 617069e185a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+180E 617069e1a08e6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+200B 617069e2808b6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+200C 617069e2808c6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+200D 617069e2808d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+200E 617069e2808e6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+200F 617069e2808f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2028 617069e280a86b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202A 617069e280aa6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202B 617069e280ab6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202C 617069e280ac6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202D 617069e280ad6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202E 617069e280ae6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+202F 617069e280af6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2060 617069e281a06b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2065 617069e281a56b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2066 617069e281a66b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2067 617069e281a76b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2068 617069e281a86b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+2069 617069e281a96b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+3000 617069e380806b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+3164 617069e385a46b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+E0001 617069f3a080816b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+E0100 617069f3a084806b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FE0F 617069efb88f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FEFF 617069efbbbf6b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFA0 617069efbea06b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF0 617069efbfb06b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF1 617069efbfb16b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF2 617069efbfb26b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF3 617069efbfb36b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF4 617069efbfb46b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF5 617069efbfb56b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF6 617069efbfb66b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF7 617069efbfb76b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-apikey-U+FFF8 617069efbfb86b65793a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+00A0 6175c2a074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+00AD 6175c2ad74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+034F 6175cd8f74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+061C 6175d89c74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+115F 6175e1859f74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+1160 6175e185a074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+180E 6175e1a08e74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+200B 6175e2808b74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+200C 6175e2808c74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+200D 6175e2808d74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+200E 6175e2808e74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+200F 6175e2808f74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2028 6175e280a874683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202A 6175e280aa74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202B 6175e280ab74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202C 6175e280ac74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202D 6175e280ad74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202E 6175e280ae74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+202F 6175e280af74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2060 6175e281a074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2065 6175e281a574683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2066 6175e281a674683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2067 6175e281a774683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2068 6175e281a874683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+2069 6175e281a974683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+3000 6175e3808074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+3164 6175e385a474683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+E0001 6175f3a0808174683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+E0100 6175f3a0848074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FE0F 6175efb88f74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FEFF 6175efbbbf74683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFA0 6175efbea074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF0 6175efbfb074683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF1 6175efbfb174683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF2 6175efbfb274683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF3 6175efbfb374683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF4 6175efbfb474683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF5 6175efbfb574683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF6 6175efbfb674683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF7 6175efbfb774683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-U+FFF8 6175efbfb874683a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+00A0 617574682dc2a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+00AD 617574682dc2ad746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+034F 617574682dcd8f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+061C 617574682dd89c746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+115F 617574682de1859f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+1160 617574682de185a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+180E 617574682de1a08e746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+200B 617574682de2808b746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+200C 617574682de2808c746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+200D 617574682de2808d746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+200E 617574682de2808e746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+200F 617574682de2808f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2028 617574682de280a8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202A 617574682de280aa746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202B 617574682de280ab746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202C 617574682de280ac746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202D 617574682de280ad746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202E 617574682de280ae746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+202F 617574682de280af746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2060 617574682de281a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2065 617574682de281a5746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2066 617574682de281a6746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2067 617574682de281a7746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2068 617574682de281a8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+2069 617574682de281a9746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+3000 617574682de38080746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+3164 617574682de385a4746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+E0001 617574682df3a08081746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+E0100 617574682df3a08480746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FE0F 617574682defb88f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FEFF 617574682defbbbf746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFA0 617574682defbea0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF0 617574682defbfb0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF1 617574682defbfb1746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF2 617574682defbfb2746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF3 617574682defbfb3746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF4 617574682defbfb4746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF5 617574682defbfb5746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF6 617574682defbfb6746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF7 617574682defbfb7746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth-token-U+FFF8 617574682defbfb8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+00A0 617574685fc2a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+00AD 617574685fc2ad746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+034F 617574685fcd8f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+061C 617574685fd89c746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+115F 617574685fe1859f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+1160 617574685fe185a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+180E 617574685fe1a08e746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+200B 617574685fe2808b746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+200C 617574685fe2808c746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+200D 617574685fe2808d746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+200E 617574685fe2808e746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+200F 617574685fe2808f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2028 617574685fe280a8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202A 617574685fe280aa746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202B 617574685fe280ab746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202C 617574685fe280ac746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202D 617574685fe280ad746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202E 617574685fe280ae746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+202F 617574685fe280af746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2060 617574685fe281a0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2065 617574685fe281a5746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2066 617574685fe281a6746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2067 617574685fe281a7746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2068 617574685fe281a8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+2069 617574685fe281a9746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+3000 617574685fe38080746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+3164 617574685fe385a4746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+E0001 617574685ff3a08081746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+E0100 617574685ff3a08480746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FE0F 617574685fefb88f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FEFF 617574685fefbbbf746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFA0 617574685fefbea0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF0 617574685fefbfb0746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF1 617574685fefbfb1746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF2 617574685fefbfb2746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF3 617574685fefbfb3746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF4 617574685fefbfb4746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF5 617574685fefbfb5746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF6 617574685fefbfb6746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF7 617574685fefbfb7746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-auth_token-U+FFF8 617574685fefbfb8746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+00A0 617574686f72c2a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+00AD 617574686f72c2ad697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+034F 617574686f72cd8f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+061C 617574686f72d89c697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+115F 617574686f72e1859f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+1160 617574686f72e185a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+180E 617574686f72e1a08e697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+200B 617574686f72e2808b697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+200C 617574686f72e2808c697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+200D 617574686f72e2808d697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+200E 617574686f72e2808e697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+200F 617574686f72e2808f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2028 617574686f72e280a8697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202A 617574686f72e280aa697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202B 617574686f72e280ab697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202C 617574686f72e280ac697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202D 617574686f72e280ad697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202E 617574686f72e280ae697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+202F 617574686f72e280af697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2060 617574686f72e281a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2065 617574686f72e281a5697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2066 617574686f72e281a6697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2067 617574686f72e281a7697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2068 617574686f72e281a8697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+2069 617574686f72e281a9697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+3000 617574686f72e38080697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+3164 617574686f72e385a4697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+E0001 617574686f72f3a08081697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+E0100 617574686f72f3a08480697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FE0F 617574686f72efb88f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FEFF 617574686f72efbbbf697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFA0 617574686f72efbea0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF0 617574686f72efbfb0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF1 617574686f72efbfb1697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF2 617574686f72efbfb2697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF3 617574686f72efbfb3697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF4 617574686f72efbfb4697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF5 617574686f72efbfb5697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF6 617574686f72efbfb6697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF7 617574686f72efbfb7697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-authorization-U+FFF8 617574686f72efbfb8697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+00A0 636f6fc2a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+00AD 636f6fc2ad6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+034F 636f6fcd8f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+061C 636f6fd89c6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+115F 636f6fe1859f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+1160 636f6fe185a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+180E 636f6fe1a08e6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+200B 636f6fe2808b6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+200C 636f6fe2808c6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+200D 636f6fe2808d6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+200E 636f6fe2808e6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+200F 636f6fe2808f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2028 636f6fe280a86b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202A 636f6fe280aa6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202B 636f6fe280ab6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202C 636f6fe280ac6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202D 636f6fe280ad6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202E 636f6fe280ae6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+202F 636f6fe280af6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2060 636f6fe281a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2065 636f6fe281a56b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2066 636f6fe281a66b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2067 636f6fe281a76b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2068 636f6fe281a86b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+2069 636f6fe281a96b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+3000 636f6fe380806b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+3164 636f6fe385a46b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+E0001 636f6ff3a080816b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+E0100 636f6ff3a084806b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FE0F 636f6fefb88f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FEFF 636f6fefbbbf6b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFA0 636f6fefbea06b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF0 636f6fefbfb06b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF1 636f6fefbfb16b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF2 636f6fefbfb26b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF3 636f6fefbfb36b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF4 636f6fefbfb46b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF5 636f6fefbfb56b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF6 636f6fefbfb66b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF7 636f6fefbfb76b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-cookie-U+FFF8 636f6fefbfb86b69653a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+00A0 6372656465c2a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+00AD 6372656465c2ad6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+034F 6372656465cd8f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+061C 6372656465d89c6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+115F 6372656465e1859f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+1160 6372656465e185a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+180E 6372656465e1a08e6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+200B 6372656465e2808b6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+200C 6372656465e2808c6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+200D 6372656465e2808d6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+200E 6372656465e2808e6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+200F 6372656465e2808f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2028 6372656465e280a86e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202A 6372656465e280aa6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202B 6372656465e280ab6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202C 6372656465e280ac6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202D 6372656465e280ad6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202E 6372656465e280ae6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+202F 6372656465e280af6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2060 6372656465e281a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2065 6372656465e281a56e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2066 6372656465e281a66e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2067 6372656465e281a76e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2068 6372656465e281a86e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+2069 6372656465e281a96e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+3000 6372656465e380806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+3164 6372656465e385a46e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+E0001 6372656465f3a080816e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+E0100 6372656465f3a084806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FE0F 6372656465efb88f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FEFF 6372656465efbbbf6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFA0 6372656465efbea06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF0 6372656465efbfb06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF1 6372656465efbfb16e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF2 6372656465efbfb26e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF3 6372656465efbfb36e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF4 6372656465efbfb46e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF5 6372656465efbfb56e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF6 6372656465efbfb66e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF7 6372656465efbfb76e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-credential-U+FFF8 6372656465efbfb86e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+00A0 70617373c2a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+00AD 70617373c2ad776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+034F 70617373cd8f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+061C 70617373d89c776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+115F 70617373e1859f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+1160 70617373e185a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+180E 70617373e1a08e776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+200B 70617373e2808b776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+200C 70617373e2808c776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+200D 70617373e2808d776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+200E 70617373e2808e776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+200F 70617373e2808f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2028 70617373e280a8776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202A 70617373e280aa776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202B 70617373e280ab776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202C 70617373e280ac776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202D 70617373e280ad776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202E 70617373e280ae776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+202F 70617373e280af776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2060 70617373e281a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2065 70617373e281a5776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2066 70617373e281a6776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2067 70617373e281a7776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2068 70617373e281a8776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+2069 70617373e281a9776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+3000 70617373e38080776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+3164 70617373e385a4776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+E0001 70617373f3a08081776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+E0100 70617373f3a08480776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FE0F 70617373efb88f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FEFF 70617373efbbbf776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFA0 70617373efbea0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF0 70617373efbfb0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF1 70617373efbfb1776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF2 70617373efbfb2776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF3 70617373efbfb3776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF4 70617373efbfb4776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF5 70617373efbfb5776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF6 70617373efbfb6776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF7 70617373efbfb7776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-password-U+FFF8 70617373efbfb8776f72643a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+00A0 70726f78792d617574c2a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+00AD 70726f78792d617574c2ad686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+034F 70726f78792d617574cd8f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+061C 70726f78792d617574d89c686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+115F 70726f78792d617574e1859f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+1160 70726f78792d617574e185a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+180E 70726f78792d617574e1a08e686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+200B 70726f78792d617574e2808b686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+200C 70726f78792d617574e2808c686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+200D 70726f78792d617574e2808d686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+200E 70726f78792d617574e2808e686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+200F 70726f78792d617574e2808f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2028 70726f78792d617574e280a8686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202A 70726f78792d617574e280aa686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202B 70726f78792d617574e280ab686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202C 70726f78792d617574e280ac686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202D 70726f78792d617574e280ad686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202E 70726f78792d617574e280ae686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+202F 70726f78792d617574e280af686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2060 70726f78792d617574e281a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2065 70726f78792d617574e281a5686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2066 70726f78792d617574e281a6686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2067 70726f78792d617574e281a7686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2068 70726f78792d617574e281a8686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+2069 70726f78792d617574e281a9686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+3000 70726f78792d617574e38080686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+3164 70726f78792d617574e385a4686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+E0001 70726f78792d617574f3a08081686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+E0100 70726f78792d617574f3a08480686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FE0F 70726f78792d617574efb88f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FEFF 70726f78792d617574efbbbf686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFA0 70726f78792d617574efbea0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF0 70726f78792d617574efbfb0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF1 70726f78792d617574efbfb1686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF2 70726f78792d617574efbfb2686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF3 70726f78792d617574efbfb3686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF4 70726f78792d617574efbfb4686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF5 70726f78792d617574efbfb5686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF6 70726f78792d617574efbfb6686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF7 70726f78792d617574efbfb7686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-proxy-authorization-U+FFF8 70726f78792d617574efbfb8686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+00A0 736563c2a07265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+00AD 736563c2ad7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+034F 736563cd8f7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+061C 736563d89c7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+115F 736563e1859f7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+1160 736563e185a07265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+180E 736563e1a08e7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+200B 736563e2808b7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+200C 736563e2808c7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+200D 736563e2808d7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+200E 736563e2808e7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+200F 736563e2808f7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2028 736563e280a87265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202A 736563e280aa7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202B 736563e280ab7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202C 736563e280ac7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202D 736563e280ad7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202E 736563e280ae7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+202F 736563e280af7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2060 736563e281a07265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2065 736563e281a57265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2066 736563e281a67265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2067 736563e281a77265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2068 736563e281a87265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+2069 736563e281a97265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+3000 736563e380807265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+3164 736563e385a47265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+E0001 736563f3a080817265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+E0100 736563f3a084807265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FE0F 736563efb88f7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FEFF 736563efbbbf7265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFA0 736563efbea07265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF0 736563efbfb07265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF1 736563efbfb17265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF2 736563efbfb27265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF3 736563efbfb37265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF4 736563efbfb47265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF5 736563efbfb57265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF6 736563efbfb67265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF7 736563efbfb77265743a2053594e5448455449435f4f50415155455f313233343536 true +key-secret-U+FFF8 736563efbfb87265743a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+00A0 746fc2a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+00AD 746fc2ad6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+034F 746fcd8f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+061C 746fd89c6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+115F 746fe1859f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+1160 746fe185a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+180E 746fe1a08e6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+200B 746fe2808b6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+200C 746fe2808c6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+200D 746fe2808d6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+200E 746fe2808e6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+200F 746fe2808f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2028 746fe280a86b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202A 746fe280aa6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202B 746fe280ab6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202C 746fe280ac6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202D 746fe280ad6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202E 746fe280ae6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+202F 746fe280af6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2060 746fe281a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2065 746fe281a56b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2066 746fe281a66b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2067 746fe281a76b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2068 746fe281a86b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+2069 746fe281a96b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+3000 746fe380806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+3164 746fe385a46b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+E0001 746ff3a080816b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+E0100 746ff3a084806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FE0F 746fefb88f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FEFF 746fefbbbf6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFA0 746fefbea06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF0 746fefbfb06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF1 746fefbfb16b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF2 746fefbfb26b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF3 746fefbfb36b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF4 746fefbfb46b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF5 746fefbfb56b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF6 746fefbfb66b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF7 746fefbfb76b656e3a2053594e5448455449435f4f50415155455f313233343536 true +key-token-U+FFF8 746fefbfb86b656e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-access_token 6163636573735f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-api-key 6170692d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +plain-api_key 6170695f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +plain-apikey 6170696b65793a2053594e5448455449435f4f50415155455f313233343536 true +plain-auth 617574683a2053594e5448455449435f4f50415155455f313233343536 true +plain-auth-token 617574682d746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-auth_token 617574685f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-authorization 617574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-bearer 4265617265722053594e5448455449435f4f50415155455f313233343536 true +plain-benign 74686520717569636b2062726f776e20666f78206a756d7073206f76657220746865206c617a7920646f67 false +plain-benign-bearerish 626561726572697368206e6f7465 false +plain-cookie 636f6f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +plain-credential 63726564656e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +plain-password 70617373776f72643a2053594e5448455449435f4f50415155455f313233343536 true +plain-proxy-authorization 70726f78792d617574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +plain-secret 7365637265743a2053594e5448455449435f4f50415155455f313233343536 true +plain-token 746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+00A0 746f6b656ec2a03a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+00AD 746f6b656ec2ad3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+034F 746f6b656ecd8f3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+061C 746f6b656ed89c3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+115F 746f6b656ee1859f3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+1160 746f6b656ee185a03a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+180E 746f6b656ee1a08e3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+200B 746f6b656ee2808b3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+200C 746f6b656ee2808c3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+200D 746f6b656ee2808d3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+200E 746f6b656ee2808e3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+200F 746f6b656ee2808f3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2028 746f6b656ee280a83a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202A 746f6b656ee280aa3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202B 746f6b656ee280ab3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202C 746f6b656ee280ac3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202D 746f6b656ee280ad3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202E 746f6b656ee280ae3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+202F 746f6b656ee280af3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2060 746f6b656ee281a03a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2065 746f6b656ee281a53a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2066 746f6b656ee281a63a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2067 746f6b656ee281a73a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2068 746f6b656ee281a83a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+2069 746f6b656ee281a93a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+3000 746f6b656ee380803a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+3164 746f6b656ee385a43a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+E0001 746f6b656ef3a080813a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+E0100 746f6b656ef3a084803a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FE0F 746f6b656eefb88f3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FEFF 746f6b656eefbbbf3a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFA0 746f6b656eefbea03a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF0 746f6b656eefbfb03a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF1 746f6b656eefbfb13a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF2 746f6b656eefbfb23a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF3 746f6b656eefbfb33a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF4 746f6b656eefbfb43a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF5 746f6b656eefbfb53a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF6 746f6b656eefbfb63a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF7 746f6b656eefbfb73a2053594e5448455449435f4f50415155455f313233343536 true +token-value-U+FFF8 746f6b656eefbfb83a2053594e5448455449435f4f50415155455f313233343536 true + +# ---- CTX-0079 round 2: case-form, non-bearer, credential-name, and +# NORM-1-in-key coverage, with expectations hand-derived from the contract +# transcribed at the top of the corpus generator. Both the TypeScript and the +# Rust suite execute every row; a row only one side satisfies is a defect on +# the other side, never a reason to rewrite the expectation. +# +# R1 credential shape | R2 entropy gate | R3 assignment phrase (ASCII +# case-insensitive key, optional one -/_ , optional space/tab, then : or =, +# optional space/tab, then a non-space byte) | R4 bearer phrase | R5 +# segment-aligned SCREAMING SECRET/TOKEN/PASSWORD/CREDENTIAL/API_KEY not +# followed by : or =. +case-password-lower-colon 70617373776f72643a2053594e5448455449435f4f50415155455f313233343536 true +case-password-lower-equals 70617373776f72643d2053594e5448455449435f4f50415155455f313233343536 true +case-password-Capitalized-colon 50617373776f72643a2053594e5448455449435f4f50415155455f313233343536 true +case-password-Capitalized-equals 50617373776f72643d2053594e5448455449435f4f50415155455f313233343536 true +case-password-UPPER-colon 50415353574f52443a2053594e5448455449435f4f50415155455f313233343536 true +case-password-UPPER-equals 50415353574f52443d2053594e5448455449435f4f50415155455f313233343536 true +case-password-MiXeD-colon 50615373576f52643a2053594e5448455449435f4f50415155455f313233343536 true +case-password-MiXeD-equals 50615373576f52643d2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-lower-colon 7061737377643a2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-lower-equals 7061737377643d2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-Capitalized-colon 5061737377643a2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-Capitalized-equals 5061737377643d2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-UPPER-colon 5041535357443a2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-UPPER-equals 5041535357443d2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-MiXeD-colon 5061537357643a2053594e5448455449435f4f50415155455f313233343536 true +case-passwd-MiXeD-equals 5061537357643d2053594e5448455449435f4f50415155455f313233343536 true +case-secret-lower-colon 7365637265743a2053594e5448455449435f4f50415155455f313233343536 true +case-secret-lower-equals 7365637265743d2053594e5448455449435f4f50415155455f313233343536 true +case-secret-Capitalized-colon 5365637265743a2053594e5448455449435f4f50415155455f313233343536 true +case-secret-Capitalized-equals 5365637265743d2053594e5448455449435f4f50415155455f313233343536 true +case-secret-UPPER-colon 5345435245543a2053594e5448455449435f4f50415155455f313233343536 true +case-secret-UPPER-equals 5345435245543d2053594e5448455449435f4f50415155455f313233343536 true +case-secret-MiXeD-colon 5365437245743a2053594e5448455449435f4f50415155455f313233343536 true +case-secret-MiXeD-equals 5365437245743d2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-lower-colon 6170695f6b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-lower-equals 6170695f6b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-Capitalized-colon 4170695f4b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-Capitalized-equals 4170695f4b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-UPPER-colon 4150495f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-UPPER-equals 4150495f4b45593d2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-MiXeD-colon 4170495f4b65593a2053594e5448455449435f4f50415155455f313233343536 true +case-api_key-MiXeD-equals 4170495f4b65593d2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-lower-colon 6170692d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-lower-equals 6170692d6b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-Capitalized-colon 4170692d4b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-Capitalized-equals 4170692d4b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-UPPER-colon 4150492d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-UPPER-equals 4150492d4b45593d2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-MiXeD-colon 4170492d4b65593a2053594e5448455449435f4f50415155455f313233343536 true +case-api-key-MiXeD-equals 4170492d4b65593d2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-lower-colon 6170696b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-lower-equals 6170696b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-Capitalized-colon 4170696b65793a2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-Capitalized-equals 4170696b65793d2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-UPPER-colon 4150494b45593a2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-UPPER-equals 4150494b45593d2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-MiXeD-colon 4170496b45793a2053594e5448455449435f4f50415155455f313233343536 true +case-apikey-MiXeD-equals 4170496b45793d2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-lower-colon 617574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-lower-equals 617574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-Capitalized-colon 417574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-Capitalized-equals 417574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-UPPER-colon 415554484f52495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-UPPER-equals 415554484f52495a4154494f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-MiXeD-colon 417554684f72497a4174496f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-authorization-MiXeD-equals 417554684f72497a4174496f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-lower-colon 70726f78792d617574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-lower-equals 70726f78792d617574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-Capitalized-colon 50726f78792d417574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-Capitalized-equals 50726f78792d417574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-UPPER-colon 50524f58592d415554484f52495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-UPPER-equals 50524f58592d415554484f52495a4154494f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-MiXeD-colon 50724f78592d417554684f72497a4174496f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy-authorization-MiXeD-equals 50724f78592d417554684f72497a4174496f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-lower-colon 70726f78795f617574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-lower-equals 70726f78795f617574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-Capitalized-colon 50726f78795f417574686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-Capitalized-equals 50726f78795f417574686f72697a6174696f6e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-UPPER-colon 50524f58595f415554484f52495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-UPPER-equals 50524f58595f415554484f52495a4154494f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-MiXeD-colon 50724f78595f417554684f72497a4174496f4e3a2053594e5448455449435f4f50415155455f313233343536 true +case-proxy_authorization-MiXeD-equals 50724f78595f417554684f72497a4174496f4e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-lower-colon 617574683a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-lower-equals 617574683d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-Capitalized-colon 417574683a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-Capitalized-equals 417574683d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-UPPER-colon 415554483a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-UPPER-equals 415554483d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-MiXeD-colon 417554683a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-MiXeD-equals 417554683d2053594e5448455449435f4f50415155455f313233343536 true +case-token-lower-colon 746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-token-lower-equals 746f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-token-Capitalized-colon 546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-token-Capitalized-equals 546f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-token-UPPER-colon 544f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +case-token-UPPER-equals 544f4b454e3d2053594e5448455449435f4f50415155455f313233343536 true +case-token-MiXeD-colon 546f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +case-token-MiXeD-equals 546f4b654e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-lower-colon 6163636573735f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-lower-equals 6163636573735f746f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-Capitalized-colon 4163636573735f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-Capitalized-equals 4163636573735f546f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-UPPER-colon 4143434553535f544f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-UPPER-equals 4143434553535f544f4b454e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-MiXeD-colon 4163436553735f744f6b456e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access_token-MiXeD-equals 4163436553735f744f6b456e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-lower-colon 6163636573732d746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-lower-equals 6163636573732d746f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-Capitalized-colon 4163636573732d546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-Capitalized-equals 4163636573732d546f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-UPPER-colon 4143434553532d544f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-UPPER-equals 4143434553532d544f4b454e3d2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-MiXeD-colon 4163436553732d744f6b456e3a2053594e5448455449435f4f50415155455f313233343536 true +case-access-token-MiXeD-equals 4163436553732d744f6b456e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-lower-colon 617574685f746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-lower-equals 617574685f746f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-Capitalized-colon 417574685f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-Capitalized-equals 417574685f546f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-UPPER-colon 415554485f544f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-UPPER-equals 415554485f544f4b454e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-MiXeD-colon 417554685f744f6b456e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth_token-MiXeD-equals 417554685f744f6b456e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-lower-colon 617574682d746f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-lower-equals 617574682d746f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-Capitalized-colon 417574682d546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-Capitalized-equals 417574682d546f6b656e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-UPPER-colon 415554482d544f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-UPPER-equals 415554482d544f4b454e3d2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-MiXeD-colon 417554682d744f6b456e3a2053594e5448455449435f4f50415155455f313233343536 true +case-auth-token-MiXeD-equals 417554682d744f6b456e3d2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-lower-colon 636f6f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-lower-equals 636f6f6b69653d2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-Capitalized-colon 436f6f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-Capitalized-equals 436f6f6b69653d2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-UPPER-colon 434f4f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-UPPER-equals 434f4f4b49453d2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-MiXeD-colon 436f4f6b49653a2053594e5448455449435f4f50415155455f313233343536 true +case-cookie-MiXeD-equals 436f4f6b49653d2053594e5448455449435f4f50415155455f313233343536 true +case-credential-lower-colon 63726564656e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +case-credential-lower-equals 63726564656e7469616c3d2053594e5448455449435f4f50415155455f313233343536 true +case-credential-Capitalized-colon 43726564656e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +case-credential-Capitalized-equals 43726564656e7469616c3d2053594e5448455449435f4f50415155455f313233343536 true +case-credential-UPPER-colon 43524544454e5449414c3a2053594e5448455449435f4f50415155455f313233343536 true +case-credential-UPPER-equals 43524544454e5449414c3d2053594e5448455449435f4f50415155455f313233343536 true +case-credential-MiXeD-colon 43724564456e5469416c3a2053594e5448455449435f4f50415155455f313233343536 true +case-credential-MiXeD-equals 43724564456e5469416c3d2053594e5448455449435f4f50415155455f313233343536 true +nonbearer-Authorization-colon-dquoted 417574686f72697a6174696f6e3a202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-Authorization-colon-squoted 417574686f72697a6174696f6e3a202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-Authorization-equals-dquoted 417574686f72697a6174696f6e3d202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-Authorization-equals-squoted 417574686f72697a6174696f6e3d202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-AUTHORIZATION-colon-dquoted 415554484f52495a4154494f4e3a202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-AUTHORIZATION-colon-squoted 415554484f52495a4154494f4e3a202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-AUTHORIZATION-equals-dquoted 415554484f52495a4154494f4e3d202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-AUTHORIZATION-equals-squoted 415554484f52495a4154494f4e3d202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-AuThOrIzAtIoN-colon-dquoted 417554684f72497a4174496f4e3a202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-AuThOrIzAtIoN-colon-squoted 417554684f72497a4174496f4e3a202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-AuThOrIzAtIoN-equals-dquoted 417554684f72497a4174496f4e3d202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-AuThOrIzAtIoN-equals-squoted 417554684f72497a4174496f4e3d202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-Proxy-Authorization-colon-dquoted 50726f78792d417574686f72697a6174696f6e3a202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-Proxy-Authorization-colon-squoted 50726f78792d417574686f72697a6174696f6e3a202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-Proxy-Authorization-equals-dquoted 50726f78792d417574686f72697a6174696f6e3d202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-Proxy-Authorization-equals-squoted 50726f78792d417574686f72697a6174696f6e3d202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-PROXY_AUTHORIZATION-colon-dquoted 50524f58595f415554484f52495a4154494f4e3a202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-PROXY_AUTHORIZATION-colon-squoted 50524f58595f415554484f52495a4154494f4e3a202753594e5448455449435f4f50415155455f31323334353627 true +nonbearer-PROXY_AUTHORIZATION-equals-dquoted 50524f58595f415554484f52495a4154494f4e3d202253594e5448455449435f4f50415155455f31323334353622 true +nonbearer-PROXY_AUTHORIZATION-equals-squoted 50524f58595f415554484f52495a4154494f4e3d202753594e5448455449435f4f50415155455f31323334353627 true +name-upper-MY_SECRET 4d595f534543524554 true +name-upper-GITHUB_TOKEN 4749544855425f544f4b454e true +name-upper-API_KEY 4150495f4b4559 true +name-upper-DB_PASSWORD 44425f50415353574f5244 true +name-upper-SERVICE_CREDENTIAL 534552564943455f43524544454e5449414c true +name-upper-MY_SECRET_VALUE 4d595f5345435245545f56414c5545 true +name-upper-OAUTH2_ACCESS_TOKEN 4f41555448325f4143434553535f544f4b454e true +name-upper-TOKEN 544f4b454e true +name-upper-SECRET 534543524554 true +name-upper-PASSWORD 50415353574f5244 true +name-upper-CREDENTIAL 43524544454e5449414c true +name-lower-my_secret 6d795f736563726574 false +name-lower-github_token 6769746875625f746f6b656e false +name-lower-api_key 6170695f6b6579 false +name-lower-db_password 64625f70617373776f7264 false +name-lower-service_credential 736572766963655f63726564656e7469616c false +name-lower-my_secret_value 6d795f7365637265745f76616c7565 false +name-lower-oauth2_access_token 6f61757468325f6163636573735f746f6b656e false +name-lower-token 746f6b656e false +name-lower-secret 736563726574 false +name-lower-password 70617373776f7264 false +name-lower-credential 63726564656e7469616c false +name-lower-Token 546f6b656e false +name-lower-Secret 536563726574 false +name-lower-Password 50617373776f7264 false +name-lower-mySecret 6d79536563726574 false +name-lower-my-secret 6d792d736563726574 false +name-lower-SECRETARY 534543524554415259 false +name-lower-TOKENIZE 544f4b454e495a45 false +name-lower-PASSWORDLESS 50415353574f52444c455353 false +name-lower-TOKENS 544f4b454e53 false +name-lower-PKI_KEYSTORE 504b495f4b455953544f5245 false +name-lower-PRIMARY_KEY 5052494d4152595f4b4559 false +name-lower-SORT_KEY 534f52545f4b4559 false +classkey-Token-U+0085 546fc2856b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+00A0 546fc2a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+00AD 546fc2ad6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+034F 546fcd8f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+0600 546fd8806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+0605 546fd8856b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+061C 546fd89c6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+06DD 546fdb9d6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+070F 546fdc8f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+0890 546fe0a2906b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+0891 546fe0a2916b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+08E2 546fe0a3a26b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+115F 546fe1859f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1160 546fe185a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1680 546fe19a806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+17B4 546fe19eb46b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+17B5 546fe19eb56b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+180B 546fe1a08b6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+180F 546fe1a08f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+2000 546fe280806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+200F 546fe2808f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+2028 546fe280a86b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+202F 546fe280af6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+205F 546fe2819f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+206F 546fe281af6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+3000 546fe380806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+3164 546fe385a46b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FE00 546fefb8806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FE0F 546fefb88f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FEFF 546fefbbbf6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FFA0 546fefbea06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FFF0 546fefbfb06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+FFFB 546fefbfbb6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+110BD 546ff09182bd6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+110CD 546ff091838d6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+13430 546ff09390b06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1343F 546ff09390bf6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1BCA0 546ff09bb2a06b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1BCA3 546ff09bb2a36b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1D173 546ff09d85b36b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+1D17A 546ff09d85ba6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+E0000 546ff3a080806b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Token-U+E0FFF 546ff3a0bfbf6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+0085 544fc2854b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+00A0 544fc2a04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+00AD 544fc2ad4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+034F 544fcd8f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+0600 544fd8804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+0605 544fd8854b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+061C 544fd89c4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+06DD 544fdb9d4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+070F 544fdc8f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+0890 544fe0a2904b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+0891 544fe0a2914b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+08E2 544fe0a3a24b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+115F 544fe1859f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1160 544fe185a04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1680 544fe19a804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+17B4 544fe19eb44b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+17B5 544fe19eb54b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+180B 544fe1a08b4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+180F 544fe1a08f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+2000 544fe280804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+200F 544fe2808f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+2028 544fe280a84b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+202F 544fe280af4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+205F 544fe2819f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+206F 544fe281af4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+3000 544fe380804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+3164 544fe385a44b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FE00 544fefb8804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FE0F 544fefb88f4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FEFF 544fefbbbf4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FFA0 544fefbea04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FFF0 544fefbfb04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+FFFB 544fefbfbb4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+110BD 544ff09182bd4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+110CD 544ff091838d4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+13430 544ff09390b04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1343F 544ff09390bf4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1BCA0 544ff09bb2a04b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1BCA3 544ff09bb2a34b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1D173 544ff09d85b34b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+1D17A 544ff09d85ba4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+E0000 544ff3a080804b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-TOKEN-U+E0FFF 544ff3a0bfbf4b454e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+0085 546fc2854b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+00A0 546fc2a04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+00AD 546fc2ad4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+034F 546fcd8f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+0600 546fd8804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+0605 546fd8854b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+061C 546fd89c4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+06DD 546fdb9d4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+070F 546fdc8f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+0890 546fe0a2904b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+0891 546fe0a2914b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+08E2 546fe0a3a24b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+115F 546fe1859f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1160 546fe185a04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1680 546fe19a804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+17B4 546fe19eb44b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+17B5 546fe19eb54b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+180B 546fe1a08b4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+180F 546fe1a08f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+2000 546fe280804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+200F 546fe2808f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+2028 546fe280a84b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+202F 546fe280af4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+205F 546fe2819f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+206F 546fe281af4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+3000 546fe380804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+3164 546fe385a44b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FE00 546fefb8804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FE0F 546fefb88f4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FEFF 546fefbbbf4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FFA0 546fefbea04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FFF0 546fefbfb04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+FFFB 546fefbfbb4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+110BD 546ff09182bd4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+110CD 546ff091838d4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+13430 546ff09390b04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1343F 546ff09390bf4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1BCA0 546ff09bb2a04b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1BCA3 546ff09bb2a34b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1D173 546ff09d85b34b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+1D17A 546ff09d85ba4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+E0000 546ff3a080804b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-ToKeN-U+E0FFF 546ff3a0bfbf4b654e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+0085 417574686f72c285697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+00A0 417574686f72c2a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+00AD 417574686f72c2ad697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+034F 417574686f72cd8f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+0600 417574686f72d880697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+0605 417574686f72d885697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+061C 417574686f72d89c697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+06DD 417574686f72db9d697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+070F 417574686f72dc8f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+0890 417574686f72e0a290697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+0891 417574686f72e0a291697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+08E2 417574686f72e0a3a2697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+115F 417574686f72e1859f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1160 417574686f72e185a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1680 417574686f72e19a80697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+17B4 417574686f72e19eb4697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+17B5 417574686f72e19eb5697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+180B 417574686f72e1a08b697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+180F 417574686f72e1a08f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+2000 417574686f72e28080697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+200F 417574686f72e2808f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+2028 417574686f72e280a8697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+202F 417574686f72e280af697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+205F 417574686f72e2819f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+206F 417574686f72e281af697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+3000 417574686f72e38080697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+3164 417574686f72e385a4697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FE00 417574686f72efb880697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FE0F 417574686f72efb88f697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FEFF 417574686f72efbbbf697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FFA0 417574686f72efbea0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FFF0 417574686f72efbfb0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+FFFB 417574686f72efbfbb697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+110BD 417574686f72f09182bd697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+110CD 417574686f72f091838d697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+13430 417574686f72f09390b0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1343F 417574686f72f09390bf697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1BCA0 417574686f72f09bb2a0697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1BCA3 417574686f72f09bb2a3697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1D173 417574686f72f09d85b3697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+1D17A 417574686f72f09d85ba697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+E0000 417574686f72f3a08080697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Authorization-U+E0FFF 417574686f72f3a0bfbf697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+0085 415554484f52c285495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+00A0 415554484f52c2a0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+00AD 415554484f52c2ad495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+034F 415554484f52cd8f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+0600 415554484f52d880495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+0605 415554484f52d885495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+061C 415554484f52d89c495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+06DD 415554484f52db9d495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+070F 415554484f52dc8f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+0890 415554484f52e0a290495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+0891 415554484f52e0a291495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+08E2 415554484f52e0a3a2495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+115F 415554484f52e1859f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1160 415554484f52e185a0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1680 415554484f52e19a80495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+17B4 415554484f52e19eb4495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+17B5 415554484f52e19eb5495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+180B 415554484f52e1a08b495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+180F 415554484f52e1a08f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+2000 415554484f52e28080495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+200F 415554484f52e2808f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+2028 415554484f52e280a8495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+202F 415554484f52e280af495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+205F 415554484f52e2819f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+206F 415554484f52e281af495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+3000 415554484f52e38080495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+3164 415554484f52e385a4495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FE00 415554484f52efb880495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FE0F 415554484f52efb88f495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FEFF 415554484f52efbbbf495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FFA0 415554484f52efbea0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FFF0 415554484f52efbfb0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+FFFB 415554484f52efbfbb495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+110BD 415554484f52f09182bd495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+110CD 415554484f52f091838d495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+13430 415554484f52f09390b0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1343F 415554484f52f09390bf495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1BCA0 415554484f52f09bb2a0495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1BCA3 415554484f52f09bb2a3495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1D173 415554484f52f09d85b3495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+1D17A 415554484f52f09d85ba495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+E0000 415554484f52f3a08080495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-AUTHORIZATION-U+E0FFF 415554484f52f3a0bfbf495a4154494f4e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+0085 415049c2855f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+00A0 415049c2a05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+00AD 415049c2ad5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+034F 415049cd8f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+0600 415049d8805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+0605 415049d8855f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+061C 415049d89c5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+06DD 415049db9d5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+070F 415049dc8f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+0890 415049e0a2905f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+0891 415049e0a2915f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+08E2 415049e0a3a25f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+115F 415049e1859f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1160 415049e185a05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1680 415049e19a805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+17B4 415049e19eb45f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+17B5 415049e19eb55f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+180B 415049e1a08b5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+180F 415049e1a08f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+2000 415049e280805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+200F 415049e2808f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+2028 415049e280a85f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+202F 415049e280af5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+205F 415049e2819f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+206F 415049e281af5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+3000 415049e380805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+3164 415049e385a45f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FE00 415049efb8805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FE0F 415049efb88f5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FEFF 415049efbbbf5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FFA0 415049efbea05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FFF0 415049efbfb05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+FFFB 415049efbfbb5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+110BD 415049f09182bd5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+110CD 415049f091838d5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+13430 415049f09390b05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1343F 415049f09390bf5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1BCA0 415049f09bb2a05f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1BCA3 415049f09bb2a35f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1D173 415049f09d85b35f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+1D17A 415049f09d85ba5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+E0000 415049f3a080805f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API_KEY-U+E0FFF 415049f3a0bfbf5f4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+0085 436f6fc2856b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+00A0 436f6fc2a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+00AD 436f6fc2ad6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+034F 436f6fcd8f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+0600 436f6fd8806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+0605 436f6fd8856b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+061C 436f6fd89c6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+06DD 436f6fdb9d6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+070F 436f6fdc8f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+0890 436f6fe0a2906b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+0891 436f6fe0a2916b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+08E2 436f6fe0a3a26b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+115F 436f6fe1859f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1160 436f6fe185a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1680 436f6fe19a806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+17B4 436f6fe19eb46b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+17B5 436f6fe19eb56b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+180B 436f6fe1a08b6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+180F 436f6fe1a08f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+2000 436f6fe280806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+200F 436f6fe2808f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+2028 436f6fe280a86b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+202F 436f6fe280af6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+205F 436f6fe2819f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+206F 436f6fe281af6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+3000 436f6fe380806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+3164 436f6fe385a46b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FE00 436f6fefb8806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FE0F 436f6fefb88f6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FEFF 436f6fefbbbf6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FFA0 436f6fefbea06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FFF0 436f6fefbfb06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+FFFB 436f6fefbfbb6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+110BD 436f6ff09182bd6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+110CD 436f6ff091838d6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+13430 436f6ff09390b06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1343F 436f6ff09390bf6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1BCA0 436f6ff09bb2a06b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1BCA3 436f6ff09bb2a36b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1D173 436f6ff09d85b36b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+1D17A 436f6ff09d85ba6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+E0000 436f6ff3a080806b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Cookie-U+E0FFF 436f6ff3a0bfbf6b69653a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+0085 434f4fc2854b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+00A0 434f4fc2a04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+00AD 434f4fc2ad4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+034F 434f4fcd8f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+0600 434f4fd8804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+0605 434f4fd8854b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+061C 434f4fd89c4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+06DD 434f4fdb9d4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+070F 434f4fdc8f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+0890 434f4fe0a2904b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+0891 434f4fe0a2914b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+08E2 434f4fe0a3a24b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+115F 434f4fe1859f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1160 434f4fe185a04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1680 434f4fe19a804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+17B4 434f4fe19eb44b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+17B5 434f4fe19eb54b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+180B 434f4fe1a08b4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+180F 434f4fe1a08f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+2000 434f4fe280804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+200F 434f4fe2808f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+2028 434f4fe280a84b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+202F 434f4fe280af4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+205F 434f4fe2819f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+206F 434f4fe281af4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+3000 434f4fe380804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+3164 434f4fe385a44b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FE00 434f4fefb8804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FE0F 434f4fefb88f4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FEFF 434f4fefbbbf4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FFA0 434f4fefbea04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FFF0 434f4fefbfb04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+FFFB 434f4fefbfbb4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+110BD 434f4ff09182bd4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+110CD 434f4ff091838d4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+13430 434f4ff09390b04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1343F 434f4ff09390bf4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1BCA0 434f4ff09bb2a04b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1BCA3 434f4ff09bb2a34b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1D173 434f4ff09d85b34b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+1D17A 434f4ff09d85ba4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+E0000 434f4ff3a080804b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-COOKIE-U+E0FFF 434f4ff3a0bfbf4b49453a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+0085 50617373c285776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+00A0 50617373c2a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+00AD 50617373c2ad776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+034F 50617373cd8f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+0600 50617373d880776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+0605 50617373d885776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+061C 50617373d89c776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+06DD 50617373db9d776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+070F 50617373dc8f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+0890 50617373e0a290776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+0891 50617373e0a291776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+08E2 50617373e0a3a2776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+115F 50617373e1859f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1160 50617373e185a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1680 50617373e19a80776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+17B4 50617373e19eb4776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+17B5 50617373e19eb5776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+180B 50617373e1a08b776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+180F 50617373e1a08f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+2000 50617373e28080776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+200F 50617373e2808f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+2028 50617373e280a8776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+202F 50617373e280af776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+205F 50617373e2819f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+206F 50617373e281af776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+3000 50617373e38080776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+3164 50617373e385a4776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FE00 50617373efb880776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FE0F 50617373efb88f776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FEFF 50617373efbbbf776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FFA0 50617373efbea0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FFF0 50617373efbfb0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+FFFB 50617373efbfbb776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+110BD 50617373f09182bd776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+110CD 50617373f091838d776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+13430 50617373f09390b0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1343F 50617373f09390bf776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1BCA0 50617373f09bb2a0776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1BCA3 50617373f09bb2a3776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1D173 50617373f09d85b3776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+1D17A 50617373f09d85ba776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+E0000 50617373f3a08080776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Password-U+E0FFF 50617373f3a0bfbf776f72643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+0085 50415353c285574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+00A0 50415353c2a0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+00AD 50415353c2ad574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+034F 50415353cd8f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+0600 50415353d880574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+0605 50415353d885574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+061C 50415353d89c574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+06DD 50415353db9d574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+070F 50415353dc8f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+0890 50415353e0a290574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+0891 50415353e0a291574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+08E2 50415353e0a3a2574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+115F 50415353e1859f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1160 50415353e185a0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1680 50415353e19a80574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+17B4 50415353e19eb4574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+17B5 50415353e19eb5574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+180B 50415353e1a08b574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+180F 50415353e1a08f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+2000 50415353e28080574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+200F 50415353e2808f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+2028 50415353e280a8574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+202F 50415353e280af574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+205F 50415353e2819f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+206F 50415353e281af574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+3000 50415353e38080574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+3164 50415353e385a4574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FE00 50415353efb880574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FE0F 50415353efb88f574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FEFF 50415353efbbbf574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FFA0 50415353efbea0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FFF0 50415353efbfb0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+FFFB 50415353efbfbb574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+110BD 50415353f09182bd574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+110CD 50415353f091838d574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+13430 50415353f09390b0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1343F 50415353f09390bf574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1BCA0 50415353f09bb2a0574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1BCA3 50415353f09bb2a3574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1D173 50415353f09d85b3574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+1D17A 50415353f09d85ba574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+E0000 50415353f3a08080574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-PASSWORD-U+E0FFF 50415353f3a0bfbf574f52443a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+0085 536563c2857265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+00A0 536563c2a07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+00AD 536563c2ad7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+034F 536563cd8f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+0600 536563d8807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+0605 536563d8857265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+061C 536563d89c7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+06DD 536563db9d7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+070F 536563dc8f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+0890 536563e0a2907265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+0891 536563e0a2917265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+08E2 536563e0a3a27265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+115F 536563e1859f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1160 536563e185a07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1680 536563e19a807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+17B4 536563e19eb47265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+17B5 536563e19eb57265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+180B 536563e1a08b7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+180F 536563e1a08f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+2000 536563e280807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+200F 536563e2808f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+2028 536563e280a87265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+202F 536563e280af7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+205F 536563e2819f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+206F 536563e281af7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+3000 536563e380807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+3164 536563e385a47265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FE00 536563efb8807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FE0F 536563efb88f7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FEFF 536563efbbbf7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FFA0 536563efbea07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FFF0 536563efbfb07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+FFFB 536563efbfbb7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+110BD 536563f09182bd7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+110CD 536563f091838d7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+13430 536563f09390b07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1343F 536563f09390bf7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1BCA0 536563f09bb2a07265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1BCA3 536563f09bb2a37265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1D173 536563f09d85b37265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+1D17A 536563f09d85ba7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+E0000 536563f3a080807265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Secret-U+E0FFF 536563f3a0bfbf7265743a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+0085 534543c2855245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+00A0 534543c2a05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+00AD 534543c2ad5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+034F 534543cd8f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+0600 534543d8805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+0605 534543d8855245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+061C 534543d89c5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+06DD 534543db9d5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+070F 534543dc8f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+0890 534543e0a2905245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+0891 534543e0a2915245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+08E2 534543e0a3a25245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+115F 534543e1859f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1160 534543e185a05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1680 534543e19a805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+17B4 534543e19eb45245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+17B5 534543e19eb55245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+180B 534543e1a08b5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+180F 534543e1a08f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+2000 534543e280805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+200F 534543e2808f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+2028 534543e280a85245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+202F 534543e280af5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+205F 534543e2819f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+206F 534543e281af5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+3000 534543e380805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+3164 534543e385a45245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FE00 534543efb8805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FE0F 534543efb88f5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FEFF 534543efbbbf5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FFA0 534543efbea05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FFF0 534543efbfb05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+FFFB 534543efbfbb5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+110BD 534543f09182bd5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+110CD 534543f091838d5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+13430 534543f09390b05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1343F 534543f09390bf5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1BCA0 534543f09bb2a05245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1BCA3 534543f09bb2a35245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1D173 534543f09d85b35245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+1D17A 534543f09d85ba5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+E0000 534543f3a080805245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-SECRET-U+E0FFF 534543f3a0bfbf5245543a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+0085 4372656465c2856e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+00A0 4372656465c2a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+00AD 4372656465c2ad6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+034F 4372656465cd8f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+0600 4372656465d8806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+0605 4372656465d8856e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+061C 4372656465d89c6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+06DD 4372656465db9d6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+070F 4372656465dc8f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+0890 4372656465e0a2906e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+0891 4372656465e0a2916e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+08E2 4372656465e0a3a26e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+115F 4372656465e1859f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1160 4372656465e185a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1680 4372656465e19a806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+17B4 4372656465e19eb46e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+17B5 4372656465e19eb56e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+180B 4372656465e1a08b6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+180F 4372656465e1a08f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+2000 4372656465e280806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+200F 4372656465e2808f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+2028 4372656465e280a86e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+202F 4372656465e280af6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+205F 4372656465e2819f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+206F 4372656465e281af6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+3000 4372656465e380806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+3164 4372656465e385a46e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FE00 4372656465efb8806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FE0F 4372656465efb88f6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FEFF 4372656465efbbbf6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FFA0 4372656465efbea06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FFF0 4372656465efbfb06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+FFFB 4372656465efbfbb6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+110BD 4372656465f09182bd6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+110CD 4372656465f091838d6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+13430 4372656465f09390b06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1343F 4372656465f09390bf6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1BCA0 4372656465f09bb2a06e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1BCA3 4372656465f09bb2a36e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1D173 4372656465f09d85b36e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+1D17A 4372656465f09d85ba6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+E0000 4372656465f3a080806e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Credential-U+E0FFF 4372656465f3a0bfbf6e7469616c3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+0085 4175c28574683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+00A0 4175c2a074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+00AD 4175c2ad74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+034F 4175cd8f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+0600 4175d88074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+0605 4175d88574683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+061C 4175d89c74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+06DD 4175db9d74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+070F 4175dc8f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+0890 4175e0a29074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+0891 4175e0a29174683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+08E2 4175e0a3a274683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+115F 4175e1859f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1160 4175e185a074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1680 4175e19a8074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+17B4 4175e19eb474683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+17B5 4175e19eb574683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+180B 4175e1a08b74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+180F 4175e1a08f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+2000 4175e2808074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+200F 4175e2808f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+2028 4175e280a874683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+202F 4175e280af74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+205F 4175e2819f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+206F 4175e281af74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+3000 4175e3808074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+3164 4175e385a474683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FE00 4175efb88074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FE0F 4175efb88f74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FEFF 4175efbbbf74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FFA0 4175efbea074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FFF0 4175efbfb074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+FFFB 4175efbfbb74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+110BD 4175f09182bd74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+110CD 4175f091838d74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+13430 4175f09390b074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1343F 4175f09390bf74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1BCA0 4175f09bb2a074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1BCA3 4175f09bb2a374683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1D173 4175f09d85b374683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+1D17A 4175f09d85ba74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+E0000 4175f3a0808074683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Auth-U+E0FFF 4175f3a0bfbf74683a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+0085 416363657373c2855f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+00A0 416363657373c2a05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+00AD 416363657373c2ad5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+034F 416363657373cd8f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+0600 416363657373d8805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+0605 416363657373d8855f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+061C 416363657373d89c5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+06DD 416363657373db9d5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+070F 416363657373dc8f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+0890 416363657373e0a2905f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+0891 416363657373e0a2915f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+08E2 416363657373e0a3a25f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+115F 416363657373e1859f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1160 416363657373e185a05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1680 416363657373e19a805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+17B4 416363657373e19eb45f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+17B5 416363657373e19eb55f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+180B 416363657373e1a08b5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+180F 416363657373e1a08f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+2000 416363657373e280805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+200F 416363657373e2808f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+2028 416363657373e280a85f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+202F 416363657373e280af5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+205F 416363657373e2819f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+206F 416363657373e281af5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+3000 416363657373e380805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+3164 416363657373e385a45f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FE00 416363657373efb8805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FE0F 416363657373efb88f5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FEFF 416363657373efbbbf5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FFA0 416363657373efbea05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FFF0 416363657373efbfb05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+FFFB 416363657373efbfbb5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+110BD 416363657373f09182bd5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+110CD 416363657373f091838d5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+13430 416363657373f09390b05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1343F 416363657373f09390bf5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1BCA0 416363657373f09bb2a05f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1BCA3 416363657373f09bb2a35f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1D173 416363657373f09d85b35f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+1D17A 416363657373f09d85ba5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+E0000 416363657373f3a080805f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Access_Token-U+E0FFF 416363657373f3a0bfbf5f546f6b656e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+0085 50726f78795f417574c285686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+00A0 50726f78795f417574c2a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+00AD 50726f78795f417574c2ad686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+034F 50726f78795f417574cd8f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+0600 50726f78795f417574d880686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+0605 50726f78795f417574d885686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+061C 50726f78795f417574d89c686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+06DD 50726f78795f417574db9d686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+070F 50726f78795f417574dc8f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+0890 50726f78795f417574e0a290686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+0891 50726f78795f417574e0a291686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+08E2 50726f78795f417574e0a3a2686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+115F 50726f78795f417574e1859f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1160 50726f78795f417574e185a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1680 50726f78795f417574e19a80686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+17B4 50726f78795f417574e19eb4686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+17B5 50726f78795f417574e19eb5686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+180B 50726f78795f417574e1a08b686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+180F 50726f78795f417574e1a08f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+2000 50726f78795f417574e28080686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+200F 50726f78795f417574e2808f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+2028 50726f78795f417574e280a8686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+202F 50726f78795f417574e280af686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+205F 50726f78795f417574e2819f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+206F 50726f78795f417574e281af686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+3000 50726f78795f417574e38080686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+3164 50726f78795f417574e385a4686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FE00 50726f78795f417574efb880686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FE0F 50726f78795f417574efb88f686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FEFF 50726f78795f417574efbbbf686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FFA0 50726f78795f417574efbea0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FFF0 50726f78795f417574efbfb0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+FFFB 50726f78795f417574efbfbb686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+110BD 50726f78795f417574f09182bd686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+110CD 50726f78795f417574f091838d686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+13430 50726f78795f417574f09390b0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1343F 50726f78795f417574f09390bf686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1BCA0 50726f78795f417574f09bb2a0686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1BCA3 50726f78795f417574f09bb2a3686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1D173 50726f78795f417574f09d85b3686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+1D17A 50726f78795f417574f09d85ba686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+E0000 50726f78795f417574f3a08080686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Proxy_Authorization-U+E0FFF 50726f78795f417574f3a0bfbf686f72697a6174696f6e3a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+0085 506173c2857377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+00A0 506173c2a07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+00AD 506173c2ad7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+034F 506173cd8f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+0600 506173d8807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+0605 506173d8857377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+061C 506173d89c7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+06DD 506173db9d7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+070F 506173dc8f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+0890 506173e0a2907377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+0891 506173e0a2917377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+08E2 506173e0a3a27377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+115F 506173e1859f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1160 506173e185a07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1680 506173e19a807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+17B4 506173e19eb47377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+17B5 506173e19eb57377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+180B 506173e1a08b7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+180F 506173e1a08f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+2000 506173e280807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+200F 506173e2808f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+2028 506173e280a87377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+202F 506173e280af7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+205F 506173e2819f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+206F 506173e281af7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+3000 506173e380807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+3164 506173e385a47377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FE00 506173efb8807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FE0F 506173efb88f7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FEFF 506173efbbbf7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FFA0 506173efbea07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FFF0 506173efbfb07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+FFFB 506173efbfbb7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+110BD 506173f09182bd7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+110CD 506173f091838d7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+13430 506173f09390b07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1343F 506173f09390bf7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1BCA0 506173f09bb2a07377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1BCA3 506173f09bb2a37377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1D173 506173f09d85b37377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+1D17A 506173f09d85ba7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+E0000 506173f3a080807377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-Passwd-U+E0FFF 506173f3a0bfbf7377643a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+0085 617069c2852d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+00A0 617069c2a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+00AD 617069c2ad2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+034F 617069cd8f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+0600 617069d8802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+0605 617069d8852d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+061C 617069d89c2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+06DD 617069db9d2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+070F 617069dc8f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+0890 617069e0a2902d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+0891 617069e0a2912d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+08E2 617069e0a3a22d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+115F 617069e1859f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1160 617069e185a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1680 617069e19a802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+17B4 617069e19eb42d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+17B5 617069e19eb52d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+180B 617069e1a08b2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+180F 617069e1a08f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+2000 617069e280802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+200F 617069e2808f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+2028 617069e280a82d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+202F 617069e280af2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+205F 617069e2819f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+206F 617069e281af2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+3000 617069e380802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+3164 617069e385a42d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FE00 617069efb8802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FE0F 617069efb88f2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FEFF 617069efbbbf2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FFA0 617069efbea02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FFF0 617069efbfb02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+FFFB 617069efbfbb2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+110BD 617069f09182bd2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+110CD 617069f091838d2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+13430 617069f09390b02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1343F 617069f09390bf2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1BCA0 617069f09bb2a02d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1BCA3 617069f09bb2a32d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1D173 617069f09d85b32d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+1D17A 617069f09d85ba2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+E0000 617069f3a080802d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-api-key-U+E0FFF 617069f3a0bfbf2d6b65793a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+0085 415049c2852d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+00A0 415049c2a02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+00AD 415049c2ad2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+034F 415049cd8f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+0600 415049d8802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+0605 415049d8852d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+061C 415049d89c2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+06DD 415049db9d2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+070F 415049dc8f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+0890 415049e0a2902d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+0891 415049e0a2912d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+08E2 415049e0a3a22d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+115F 415049e1859f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1160 415049e185a02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1680 415049e19a802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+17B4 415049e19eb42d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+17B5 415049e19eb52d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+180B 415049e1a08b2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+180F 415049e1a08f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+2000 415049e280802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+200F 415049e2808f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+2028 415049e280a82d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+202F 415049e280af2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+205F 415049e2819f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+206F 415049e281af2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+3000 415049e380802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+3164 415049e385a42d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FE00 415049efb8802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FE0F 415049efb88f2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FEFF 415049efbbbf2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FFA0 415049efbea02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FFF0 415049efbfb02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+FFFB 415049efbfbb2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+110BD 415049f09182bd2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+110CD 415049f091838d2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+13430 415049f09390b02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1343F 415049f09390bf2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1BCA0 415049f09bb2a02d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1BCA3 415049f09bb2a32d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1D173 415049f09d85b32d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+1D17A 415049f09d85ba2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+E0000 415049f3a080802d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classkey-API-KEY-U+E0FFF 415049f3a0bfbf2d4b45593a2053594e5448455449435f4f50415155455f313233343536 true +classgap-key-U+0085 546f6b656ec2853d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+0085 546f6b656e3a2053594ec2855448455449435f4f50415155455f313233343536 true +classgap-bearer-U+0085 42656172657220616263646566c285313233343536 true +classgap-name-U+0085 544fc2854b454e true +classgap-prose-U+0085 68656c6c6fc285776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+00A0 546f6b656ec2a03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+00A0 546f6b656e3a2053594ec2a05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+00A0 42656172657220616263646566c2a0313233343536 true +classgap-name-U+00A0 544fc2a04b454e true +classgap-prose-U+00A0 68656c6c6fc2a0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+00AD 546f6b656ec2ad3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+00AD 546f6b656e3a2053594ec2ad5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+00AD 42656172657220616263646566c2ad313233343536 true +classgap-name-U+00AD 544fc2ad4b454e true +classgap-prose-U+00AD 68656c6c6fc2ad776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+034F 546f6b656ecd8f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+034F 546f6b656e3a2053594ecd8f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+034F 42656172657220616263646566cd8f313233343536 true +classgap-name-U+034F 544fcd8f4b454e true +classgap-prose-U+034F 68656c6c6fcd8f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+0600 546f6b656ed8803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+0600 546f6b656e3a2053594ed8805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+0600 42656172657220616263646566d880313233343536 true +classgap-name-U+0600 544fd8804b454e true +classgap-prose-U+0600 68656c6c6fd880776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+0605 546f6b656ed8853d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+0605 546f6b656e3a2053594ed8855448455449435f4f50415155455f313233343536 true +classgap-bearer-U+0605 42656172657220616263646566d885313233343536 true +classgap-name-U+0605 544fd8854b454e true +classgap-prose-U+0605 68656c6c6fd885776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+061C 546f6b656ed89c3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+061C 546f6b656e3a2053594ed89c5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+061C 42656172657220616263646566d89c313233343536 true +classgap-name-U+061C 544fd89c4b454e true +classgap-prose-U+061C 68656c6c6fd89c776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+06DD 546f6b656edb9d3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+06DD 546f6b656e3a2053594edb9d5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+06DD 42656172657220616263646566db9d313233343536 true +classgap-name-U+06DD 544fdb9d4b454e true +classgap-prose-U+06DD 68656c6c6fdb9d776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+070F 546f6b656edc8f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+070F 546f6b656e3a2053594edc8f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+070F 42656172657220616263646566dc8f313233343536 true +classgap-name-U+070F 544fdc8f4b454e true +classgap-prose-U+070F 68656c6c6fdc8f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+0890 546f6b656ee0a2903d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+0890 546f6b656e3a2053594ee0a2905448455449435f4f50415155455f313233343536 true +classgap-bearer-U+0890 42656172657220616263646566e0a290313233343536 true +classgap-name-U+0890 544fe0a2904b454e true +classgap-prose-U+0890 68656c6c6fe0a290776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+0891 546f6b656ee0a2913d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+0891 546f6b656e3a2053594ee0a2915448455449435f4f50415155455f313233343536 true +classgap-bearer-U+0891 42656172657220616263646566e0a291313233343536 true +classgap-name-U+0891 544fe0a2914b454e true +classgap-prose-U+0891 68656c6c6fe0a291776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+08E2 546f6b656ee0a3a23d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+08E2 546f6b656e3a2053594ee0a3a25448455449435f4f50415155455f313233343536 true +classgap-bearer-U+08E2 42656172657220616263646566e0a3a2313233343536 true +classgap-name-U+08E2 544fe0a3a24b454e true +classgap-prose-U+08E2 68656c6c6fe0a3a2776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+115F 546f6b656ee1859f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+115F 546f6b656e3a2053594ee1859f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+115F 42656172657220616263646566e1859f313233343536 true +classgap-name-U+115F 544fe1859f4b454e true +classgap-prose-U+115F 68656c6c6fe1859f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1160 546f6b656ee185a03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1160 546f6b656e3a2053594ee185a05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1160 42656172657220616263646566e185a0313233343536 true +classgap-name-U+1160 544fe185a04b454e true +classgap-prose-U+1160 68656c6c6fe185a0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1680 546f6b656ee19a803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1680 546f6b656e3a2053594ee19a805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1680 42656172657220616263646566e19a80313233343536 true +classgap-name-U+1680 544fe19a804b454e true +classgap-prose-U+1680 68656c6c6fe19a80776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+17B4 546f6b656ee19eb43d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+17B4 546f6b656e3a2053594ee19eb45448455449435f4f50415155455f313233343536 true +classgap-bearer-U+17B4 42656172657220616263646566e19eb4313233343536 true +classgap-name-U+17B4 544fe19eb44b454e true +classgap-prose-U+17B4 68656c6c6fe19eb4776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+17B5 546f6b656ee19eb53d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+17B5 546f6b656e3a2053594ee19eb55448455449435f4f50415155455f313233343536 true +classgap-bearer-U+17B5 42656172657220616263646566e19eb5313233343536 true +classgap-name-U+17B5 544fe19eb54b454e true +classgap-prose-U+17B5 68656c6c6fe19eb5776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+180B 546f6b656ee1a08b3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+180B 546f6b656e3a2053594ee1a08b5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+180B 42656172657220616263646566e1a08b313233343536 true +classgap-name-U+180B 544fe1a08b4b454e true +classgap-prose-U+180B 68656c6c6fe1a08b776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+180F 546f6b656ee1a08f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+180F 546f6b656e3a2053594ee1a08f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+180F 42656172657220616263646566e1a08f313233343536 true +classgap-name-U+180F 544fe1a08f4b454e true +classgap-prose-U+180F 68656c6c6fe1a08f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+2000 546f6b656ee280803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+2000 546f6b656e3a2053594ee280805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+2000 42656172657220616263646566e28080313233343536 true +classgap-name-U+2000 544fe280804b454e true +classgap-prose-U+2000 68656c6c6fe28080776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+200F 546f6b656ee2808f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+200F 546f6b656e3a2053594ee2808f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+200F 42656172657220616263646566e2808f313233343536 true +classgap-name-U+200F 544fe2808f4b454e true +classgap-prose-U+200F 68656c6c6fe2808f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+2028 546f6b656ee280a83d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+2028 546f6b656e3a2053594ee280a85448455449435f4f50415155455f313233343536 true +classgap-bearer-U+2028 42656172657220616263646566e280a8313233343536 true +classgap-name-U+2028 544fe280a84b454e true +classgap-prose-U+2028 68656c6c6fe280a8776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+202F 546f6b656ee280af3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+202F 546f6b656e3a2053594ee280af5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+202F 42656172657220616263646566e280af313233343536 true +classgap-name-U+202F 544fe280af4b454e true +classgap-prose-U+202F 68656c6c6fe280af776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+205F 546f6b656ee2819f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+205F 546f6b656e3a2053594ee2819f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+205F 42656172657220616263646566e2819f313233343536 true +classgap-name-U+205F 544fe2819f4b454e true +classgap-prose-U+205F 68656c6c6fe2819f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+206F 546f6b656ee281af3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+206F 546f6b656e3a2053594ee281af5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+206F 42656172657220616263646566e281af313233343536 true +classgap-name-U+206F 544fe281af4b454e true +classgap-prose-U+206F 68656c6c6fe281af776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+3000 546f6b656ee380803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+3000 546f6b656e3a2053594ee380805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+3000 42656172657220616263646566e38080313233343536 true +classgap-name-U+3000 544fe380804b454e true +classgap-prose-U+3000 68656c6c6fe38080776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+3164 546f6b656ee385a43d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+3164 546f6b656e3a2053594ee385a45448455449435f4f50415155455f313233343536 true +classgap-bearer-U+3164 42656172657220616263646566e385a4313233343536 true +classgap-name-U+3164 544fe385a44b454e true +classgap-prose-U+3164 68656c6c6fe385a4776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FE00 546f6b656eefb8803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FE00 546f6b656e3a2053594eefb8805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FE00 42656172657220616263646566efb880313233343536 true +classgap-name-U+FE00 544fefb8804b454e true +classgap-prose-U+FE00 68656c6c6fefb880776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FE0F 546f6b656eefb88f3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FE0F 546f6b656e3a2053594eefb88f5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FE0F 42656172657220616263646566efb88f313233343536 true +classgap-name-U+FE0F 544fefb88f4b454e true +classgap-prose-U+FE0F 68656c6c6fefb88f776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FEFF 546f6b656eefbbbf3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FEFF 546f6b656e3a2053594eefbbbf5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FEFF 42656172657220616263646566efbbbf313233343536 true +classgap-name-U+FEFF 544fefbbbf4b454e true +classgap-prose-U+FEFF 68656c6c6fefbbbf776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FFA0 546f6b656eefbea03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FFA0 546f6b656e3a2053594eefbea05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FFA0 42656172657220616263646566efbea0313233343536 true +classgap-name-U+FFA0 544fefbea04b454e true +classgap-prose-U+FFA0 68656c6c6fefbea0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FFF0 546f6b656eefbfb03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FFF0 546f6b656e3a2053594eefbfb05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FFF0 42656172657220616263646566efbfb0313233343536 true +classgap-name-U+FFF0 544fefbfb04b454e true +classgap-prose-U+FFF0 68656c6c6fefbfb0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+FFFB 546f6b656eefbfbb3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+FFFB 546f6b656e3a2053594eefbfbb5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+FFFB 42656172657220616263646566efbfbb313233343536 true +classgap-name-U+FFFB 544fefbfbb4b454e true +classgap-prose-U+FFFB 68656c6c6fefbfbb776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+110BD 546f6b656ef09182bd3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+110BD 546f6b656e3a2053594ef09182bd5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+110BD 42656172657220616263646566f09182bd313233343536 true +classgap-name-U+110BD 544ff09182bd4b454e true +classgap-prose-U+110BD 68656c6c6ff09182bd776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+110CD 546f6b656ef091838d3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+110CD 546f6b656e3a2053594ef091838d5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+110CD 42656172657220616263646566f091838d313233343536 true +classgap-name-U+110CD 544ff091838d4b454e true +classgap-prose-U+110CD 68656c6c6ff091838d776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+13430 546f6b656ef09390b03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+13430 546f6b656e3a2053594ef09390b05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+13430 42656172657220616263646566f09390b0313233343536 true +classgap-name-U+13430 544ff09390b04b454e true +classgap-prose-U+13430 68656c6c6ff09390b0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1343F 546f6b656ef09390bf3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1343F 546f6b656e3a2053594ef09390bf5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1343F 42656172657220616263646566f09390bf313233343536 true +classgap-name-U+1343F 544ff09390bf4b454e true +classgap-prose-U+1343F 68656c6c6ff09390bf776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1BCA0 546f6b656ef09bb2a03d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1BCA0 546f6b656e3a2053594ef09bb2a05448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1BCA0 42656172657220616263646566f09bb2a0313233343536 true +classgap-name-U+1BCA0 544ff09bb2a04b454e true +classgap-prose-U+1BCA0 68656c6c6ff09bb2a0776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1BCA3 546f6b656ef09bb2a33d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1BCA3 546f6b656e3a2053594ef09bb2a35448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1BCA3 42656172657220616263646566f09bb2a3313233343536 true +classgap-name-U+1BCA3 544ff09bb2a34b454e true +classgap-prose-U+1BCA3 68656c6c6ff09bb2a3776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1D173 546f6b656ef09d85b33d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1D173 546f6b656e3a2053594ef09d85b35448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1D173 42656172657220616263646566f09d85b3313233343536 true +classgap-name-U+1D173 544ff09d85b34b454e true +classgap-prose-U+1D173 68656c6c6ff09d85b3776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+1D17A 546f6b656ef09d85ba3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+1D17A 546f6b656e3a2053594ef09d85ba5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+1D17A 42656172657220616263646566f09d85ba313233343536 true +classgap-name-U+1D17A 544ff09d85ba4b454e true +classgap-prose-U+1D17A 68656c6c6ff09d85ba776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+E0000 546f6b656ef3a080803d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+E0000 546f6b656e3a2053594ef3a080805448455449435f4f50415155455f313233343536 true +classgap-bearer-U+E0000 42656172657220616263646566f3a08080313233343536 true +classgap-name-U+E0000 544ff3a080804b454e true +classgap-prose-U+E0000 68656c6c6ff3a08080776f726c642074686973206973206f7264696e6172792070726f7365 false +classgap-key-U+E0FFF 546f6b656ef3a0bfbf3d2053594e5448455449435f4f50415155455f313233343536 true +classgap-value-U+E0FFF 546f6b656e3a2053594ef3a0bfbf5448455449435f4f50415155455f313233343536 true +classgap-bearer-U+E0FFF 42656172657220616263646566f3a0bfbf313233343536 true +classgap-name-U+E0FFF 544ff3a0bfbf4b454e true +classgap-prose-U+E0FFF 68656c6c6ff3a0bfbf776f726c642074686973206973206f7264696e6172792070726f7365 false +neg-delimiter-only 546f6b656e3a false +neg-delimiter-space 546f6b656e3a20 false +neg-delimiter-tabs 546f6b656e3d0909 false +neg-delimiter-eof-equals 546f6b656e3d false +neg-r5-lookahead-colon 544f4b454e3a false +neg-r5-lookahead-equals 544f4b454e203d false +neg-r3-passwords 50617373776f7264732061726520726571756972656420746f206c6f6720696e false +neg-r3-tokens 546f6b656e7320657870697265206166746572206f6e6520686f7572 false +neg-r3-authorization-header 54686520417574686f72697a6174696f6e20686561646572206973206f7074696f6e616c false +neg-r3-authorizing 617574686f72697a6174696f6e696e673a206e6f7465 false +neg-r3-secret-prose 7365742074686520736563726574206265666f726520796f752073746172742074686520736572766572 false +neg-r3-my-secret-note 6d7920736563726574206e6f7465 false +neg-r4-bearer-alone 426561726572 false +neg-r4-joined-short 42656172657261626364656667 false +neg-r4-bearerish 626561726572697368206e6f7465 false +neg-version-string 72656c6561736520312e322e33 false +neg-uuid 31323365343536372d653839622d313264332d613435362d343236363134313734303030 false +neg-prose-slug 7372632f636f6d706f6e656e74732f566572794c6f6e67436f6d706f6e656e744e616d652f696e6465782e7473 false +neg-prose-sentence 74686520717569636b2062726f776e20666f78206a756d7073206f76657220746865206c617a7920646f67 false +neg-cookie-prose 636f6f6b6965206a617220697320656d707479 false +neg-credential-prose 63726564656e7469616c7320657870697265642c207265747279207468652072657175657374 false +neg-auth-prose 54686520746f6b656e2069732073746f72656420696e20746865207661756c74 false +neg-empty false +neg-spaces 20202020 false +pos-bearer-space 4265617265722053594e5448455449435f4f50415155455f313233343536 true +pos-bearer-upper 4245415245522053594e5448455449435f4f50415155455f313233343536 true +pos-bearer-mixed 4265417245722053594e5448455449435f4f50415155455f313233343536 true +pos-bearer-joined 4265617265726162636465666768 true +pos-bearer-joined-upper 6265617265724142434445464748 true +pos-bearer-joined-pad 42656172657261626364653d666768696a true +pos-bearer-in-assignment 417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +pos-proxy-bearer 50726f78792d417574686f72697a6174696f6e3a204265617265722053594e5448455449435f4f50415155455f313233343536 true +pos-hyphen-after-key 746f6b656e2d3a2053594e5448455449435f4f50415155455f313233343536 true +pos-underscore-after-key 746f6b656e5f3a2053594e5448455449435f4f50415155455f313233343536 true