@blamejs/blamejs-shop 0.5.19 → 0.5.21

package/lib/vendor/blamejs/lib/case-fold-classes.js

@@ -0,0 +1,491 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+// GENERATED by scripts/gen-case-fold-classes.js — do not edit by hand.
+//
+// Characters that a regular expression treats as the same under `i` but that
+// upper- and lower-casing does not lead from one to the other: a micro sign
+// and a Greek mu, a final sigma and an ordinary one, the title-case digraphs,
+// and — under `u` only — a Kelvin sign and a `k`, a long s and an `s`.
+//
+// Every other equal pair is found by casing and is not listed. Keyed by code
+// point, giving the partners that casing alone would miss.
+
+var PLAIN = {
+  452: [453],
+  454: [453],
+  455: [456],
+  457: [456],
+  458: [459],
+  460: [459],
+  497: [498],
+  499: [498],
+  837: [8126],
+  914: [976],
+  917: [1013],
+  920: [977],
+  921: [837, 8126],
+  922: [1008],
+  924: [181],
+  928: [982],
+  929: [1009],
+  931: [962],
+  934: [981],
+  946: [976],
+  949: [1013],
+  952: [977],
+  953: [837, 8126],
+  954: [1008],
+  956: [181],
+  960: [982],
+  961: [1009],
+  963: [962],
+  966: [981],
+  1042: [7296],
+  1044: [7297],
+  1054: [7298],
+  1057: [7299],
+  1058: [7300, 7301],
+  1066: [7302],
+  1074: [7296],
+  1076: [7297],
+  1086: [7298],
+  1089: [7299],
+  1090: [7300, 7301],
+  1098: [7302],
+  1122: [7303],
+  1123: [7303],
+  7300: [7301],
+  7301: [7300],
+  7776: [7835],
+  7777: [7835],
+  8126: [837],
+  42570: [7304],
+  42571: [7304],
+};
+
+var UNICODE = {
+  75: [8490],
+  83: [383],
+  107: [8490],
+  115: [383],
+  197: [8491],
+  223: [7838],
+  229: [8491],
+  452: [453],
+  454: [453],
+  455: [456],
+  457: [456],
+  458: [459],
+  460: [459],
+  497: [498],
+  499: [498],
+  837: [8126],
+  912: [8147],
+  914: [976],
+  917: [1013],
+  920: [977, 1012],
+  921: [837, 8126],
+  922: [1008],
+  924: [181],
+  928: [982],
+  929: [1009],
+  931: [962],
+  934: [981],
+  937: [8486],
+  944: [8163],
+  946: [976],
+  949: [1013],
+  952: [977, 1012],
+  953: [837, 8126],
+  954: [1008],
+  956: [181],
+  960: [982],
+  961: [1009],
+  963: [962],
+  966: [981],
+  969: [8486],
+  977: [1012],
+  1012: [920, 977],
+  1042: [7296],
+  1044: [7297],
+  1054: [7298],
+  1057: [7299],
+  1058: [7300, 7301],
+  1066: [7302],
+  1074: [7296],
+  1076: [7297],
+  1086: [7298],
+  1089: [7299],
+  1090: [7300, 7301],
+  1098: [7302],
+  1122: [7303],
+  1123: [7303],
+  7300: [7301],
+  7301: [7300],
+  7776: [7835],
+  7777: [7835],
+  8064: [8072],
+  8065: [8073],
+  8066: [8074],
+  8067: [8075],
+  8068: [8076],
+  8069: [8077],
+  8070: [8078],
+  8071: [8079],
+  8080: [8088],
+  8081: [8089],
+  8082: [8090],
+  8083: [8091],
+  8084: [8092],
+  8085: [8093],
+  8086: [8094],
+  8087: [8095],
+  8096: [8104],
+  8097: [8105],
+  8098: [8106],
+  8099: [8107],
+  8100: [8108],
+  8101: [8109],
+  8102: [8110],
+  8103: [8111],
+  8115: [8124],
+  8126: [837],
+  8131: [8140],
+  8147: [912],
+  8163: [944],
+  8179: [8188],
+  8486: [937],
+  8490: [75],
+  8491: [197],
+  42570: [7304],
+  42571: [7304],
+  64261: [64262],
+  64262: [64261],
+};
+
+// Where folding through upper case lands a character in the wrong company.
+// A dotless i upper-cases to `I`, which lower-cases to `i` — and Unicode
+// still does not call them the same character. These say which company the
+// character actually keeps.
+var PLAIN_CANONICAL = {
+  66600: 66600,
+  66601: 66601,
+  66602: 66602,
+  66603: 66603,
+  66604: 66604,
+  66605: 66605,
+  66606: 66606,
+  66607: 66607,
+  66608: 66608,
+  66609: 66609,
+  66610: 66610,
+  66611: 66611,
+  66612: 66612,
+  66613: 66613,
+  66614: 66614,
+  66615: 66615,
+  66616: 66616,
+  66617: 66617,
+  66618: 66618,
+  66619: 66619,
+  66620: 66620,
+  66621: 66621,
+  66622: 66622,
+  66623: 66623,
+  66624: 66624,
+  66625: 66625,
+  66626: 66626,
+  66627: 66627,
+  66628: 66628,
+  66629: 66629,
+  66630: 66630,
+  66631: 66631,
+  66632: 66632,
+  66633: 66633,
+  66634: 66634,
+  66635: 66635,
+  66636: 66636,
+  66637: 66637,
+  66638: 66638,
+  66639: 66639,
+  66776: 66776,
+  66777: 66777,
+  66778: 66778,
+  66779: 66779,
+  66780: 66780,
+  66781: 66781,
+  66782: 66782,
+  66783: 66783,
+  66784: 66784,
+  66785: 66785,
+  66786: 66786,
+  66787: 66787,
+  66788: 66788,
+  66789: 66789,
+  66790: 66790,
+  66791: 66791,
+  66792: 66792,
+  66793: 66793,
+  66794: 66794,
+  66795: 66795,
+  66796: 66796,
+  66797: 66797,
+  66798: 66798,
+  66799: 66799,
+  66800: 66800,
+  66801: 66801,
+  66802: 66802,
+  66803: 66803,
+  66804: 66804,
+  66805: 66805,
+  66806: 66806,
+  66807: 66807,
+  66808: 66808,
+  66809: 66809,
+  66810: 66810,
+  66811: 66811,
+  66967: 66967,
+  66968: 66968,
+  66969: 66969,
+  66970: 66970,
+  66971: 66971,
+  66972: 66972,
+  66973: 66973,
+  66974: 66974,
+  66975: 66975,
+  66976: 66976,
+  66977: 66977,
+  66979: 66979,
+  66980: 66980,
+  66981: 66981,
+  66982: 66982,
+  66983: 66983,
+  66984: 66984,
+  66985: 66985,
+  66986: 66986,
+  66987: 66987,
+  66988: 66988,
+  66989: 66989,
+  66990: 66990,
+  66991: 66991,
+  66992: 66992,
+  66993: 66993,
+  66995: 66995,
+  66996: 66996,
+  66997: 66997,
+  66998: 66998,
+  66999: 66999,
+  67000: 67000,
+  67001: 67001,
+  67003: 67003,
+  67004: 67004,
+  68800: 68800,
+  68801: 68801,
+  68802: 68802,
+  68803: 68803,
+  68804: 68804,
+  68805: 68805,
+  68806: 68806,
+  68807: 68807,
+  68808: 68808,
+  68809: 68809,
+  68810: 68810,
+  68811: 68811,
+  68812: 68812,
+  68813: 68813,
+  68814: 68814,
+  68815: 68815,
+  68816: 68816,
+  68817: 68817,
+  68818: 68818,
+  68819: 68819,
+  68820: 68820,
+  68821: 68821,
+  68822: 68822,
+  68823: 68823,
+  68824: 68824,
+  68825: 68825,
+  68826: 68826,
+  68827: 68827,
+  68828: 68828,
+  68829: 68829,
+  68830: 68830,
+  68831: 68831,
+  68832: 68832,
+  68833: 68833,
+  68834: 68834,
+  68835: 68835,
+  68836: 68836,
+  68837: 68837,
+  68838: 68838,
+  68839: 68839,
+  68840: 68840,
+  68841: 68841,
+  68842: 68842,
+  68843: 68843,
+  68844: 68844,
+  68845: 68845,
+  68846: 68846,
+  68847: 68847,
+  68848: 68848,
+  68849: 68849,
+  68850: 68850,
+  68976: 68976,
+  68977: 68977,
+  68978: 68978,
+  68979: 68979,
+  68980: 68980,
+  68981: 68981,
+  68982: 68982,
+  68983: 68983,
+  68984: 68984,
+  68985: 68985,
+  68986: 68986,
+  68987: 68987,
+  68988: 68988,
+  68989: 68989,
+  68990: 68990,
+  68991: 68991,
+  68992: 68992,
+  68993: 68993,
+  68994: 68994,
+  68995: 68995,
+  68996: 68996,
+  68997: 68997,
+  71872: 71872,
+  71873: 71873,
+  71874: 71874,
+  71875: 71875,
+  71876: 71876,
+  71877: 71877,
+  71878: 71878,
+  71879: 71879,
+  71880: 71880,
+  71881: 71881,
+  71882: 71882,
+  71883: 71883,
+  71884: 71884,
+  71885: 71885,
+  71886: 71886,
+  71887: 71887,
+  71888: 71888,
+  71889: 71889,
+  71890: 71890,
+  71891: 71891,
+  71892: 71892,
+  71893: 71893,
+  71894: 71894,
+  71895: 71895,
+  71896: 71896,
+  71897: 71897,
+  71898: 71898,
+  71899: 71899,
+  71900: 71900,
+  71901: 71901,
+  71902: 71902,
+  71903: 71903,
+  93792: 93792,
+  93793: 93793,
+  93794: 93794,
+  93795: 93795,
+  93796: 93796,
+  93797: 93797,
+  93798: 93798,
+  93799: 93799,
+  93800: 93800,
+  93801: 93801,
+  93802: 93802,
+  93803: 93803,
+  93804: 93804,
+  93805: 93805,
+  93806: 93806,
+  93807: 93807,
+  93808: 93808,
+  93809: 93809,
+  93810: 93810,
+  93811: 93811,
+  93812: 93812,
+  93813: 93813,
+  93814: 93814,
+  93815: 93815,
+  93816: 93816,
+  93817: 93817,
+  93818: 93818,
+  93819: 93819,
+  93820: 93820,
+  93821: 93821,
+  93822: 93822,
+  93823: 93823,
+  93883: 93883,
+  93884: 93884,
+  93885: 93885,
+  93886: 93886,
+  93887: 93887,
+  93888: 93888,
+  93889: 93889,
+  93890: 93890,
+  93891: 93891,
+  93892: 93892,
+  93893: 93893,
+  93894: 93894,
+  93895: 93895,
+  93896: 93896,
+  93897: 93897,
+  93898: 93898,
+  93899: 93899,
+  93900: 93900,
+  93901: 93901,
+  93902: 93902,
+  93903: 93903,
+  93904: 93904,
+  93905: 93905,
+  93906: 93906,
+  93907: 93907,
+  125218: 125218,
+  125219: 125219,
+  125220: 125220,
+  125221: 125221,
+  125222: 125222,
+  125223: 125223,
+  125224: 125224,
+  125225: 125225,
+  125226: 125226,
+  125227: 125227,
+  125228: 125228,
+  125229: 125229,
+  125230: 125230,
+  125231: 125231,
+  125232: 125232,
+  125233: 125233,
+  125234: 125234,
+  125235: 125235,
+  125236: 125236,
+  125237: 125237,
+  125238: 125238,
+  125239: 125239,
+  125240: 125240,
+  125241: 125241,
+  125242: 125242,
+  125243: 125243,
+  125244: 125244,
+  125245: 125245,
+  125246: 125246,
+  125247: 125247,
+  125248: 125248,
+  125249: 125249,
+  125250: 125250,
+  125251: 125251,
+};
+
+var UNICODE_CANONICAL = {
+  305: 305,
+  8147: 912,
+  8163: 944,
+  64262: 64261,
+};
+
+module.exports = {
+  PLAIN: PLAIN, UNICODE: UNICODE,
+  PLAIN_CANONICAL: PLAIN_CANONICAL, UNICODE_CANONICAL: UNICODE_CANONICAL,
+};

package/lib/vendor/blamejs/lib/codepoint-class.js

@@ -72,6 +72,8 @@
  *   so you can build a custom free-text screen without re-rolling the regexes.
  */
 
+var caseFoldClasses = require("./case-fold-classes");
+
 var HEX_RADIX = 16;                                                 // base-16 radix, not byte size
 
 /**
@@ -663,7 +665,136 @@ function stripUrlSchemeWhitespace(s) {
     .replace(URL_C0_SPACE_TRIM_RE, "");
 }
 
+/**
+ * @primitive  b.codepointClass.canonicalizeForCase
+ * @signature  b.codepointClass.canonicalizeForCase(codePoint, unicode)
+ * @since      0.18.19
+ * @status     stable
+ * @related    b.regexLinear.compile, b.guardRegex.assertSafe
+ *
+ * The character a regular-expression engine compares when `i` is in force,
+ * given a code point and whether the `u` (or `v`) flag applies.
+ *
+ * It is not "the upper case" and it is not "the lower case". Without `u` the
+ * language folds through upper case, keeps a character whose upper case runs to
+ * more than one character, and refuses to fold a non-ASCII character onto an
+ * ASCII one — the last of which is why `/k/i` does not match a Kelvin sign, and
+ * why converting both characters and comparing gets the wrong answer.
+ *
+ * Under `u` the rule changes to case FOLDING: the ASCII guard drops, so a long
+ * s folds onto an `s`, and an expanding upper case no longer stops the fold —
+ * a Greek eta with a iota subscript and its capital form both upper-case to two
+ * characters and are still the same character there.
+ *
+ * Two characters are the same under `i` exactly when this returns the same code
+ * point for both.
+ *
+ * @example
+ *   var same = b.codepointClass.canonicalizeForCase;
+ *   same("k".codePointAt(0), false) === same("K".codePointAt(0), false);   // → true
+ *   same("k".codePointAt(0), false) === same(0x212a, false);               // → false (Kelvin)
+ *   same("s".codePointAt(0), true)  === same(0x17f, true);                 // → true (long s, under u)
+ */
+function canonicalizeForCase(cp, unicode) {
+  var ch = String.fromCodePoint(cp);
+  var upper = ch.toUpperCase();
+  // Tolerates a table that predates this field, so the generator that WRITES
+  // the table can load this module to build it.
+  var corrections = (unicode ? caseFoldClasses.UNICODE_CANONICAL
+                             : caseFoldClasses.PLAIN_CANONICAL) || {};
+  var corrected = corrections[cp];
+  if (corrected !== undefined) return corrected;           // folding lands it wrongly
+  if (unicode) {
+    // Under `u` the rule is FOLDING, and "the upper case is more than one
+    // character" is not part of it. Where the upper case does expand there is
+    // nothing to fold through, but the character can still share a simple lower
+    // case with its class: a Greek eta with a iota subscript and its capital
+    // form both upper-case to two characters and both lower-case to the same
+    // one, so stopping at the expansion left them strangers.
+    if (_oneCodePoint(upper)) {
+      var folded = upper.toLowerCase();
+      if (_oneCodePoint(folded)) return folded.codePointAt(0);
+    }
+    var lowered = ch.toLowerCase();
+    return _oneCodePoint(lowered) ? lowered.codePointAt(0) : cp;
+  }
+  // Without `u` the rule IS upper case, and a character whose upper case runs
+  // to more than one keeps itself — which is why `/eta-with-subscript/i` does
+  // not match its own capital form although `/…/iu` does. "More than one" is
+  // counted in CODE POINTS: counting UTF-16 units would call every astral
+  // letter a multi-character mapping and leave Deseret unfolded.
+  if (_oneCodePoint(upper) === false) return cp;
+  var canon = upper.codePointAt(0);
+  if (cp >= 128 && canon < 128) return cp;
+  return canon;
+}
+
+function _oneCodePoint(s) {
+  if (s.length === 1) return true;
+  return s.length === 2 && s.codePointAt(0) > 0xFFFF;
+}
+
+/**
+ * @primitive  b.codepointClass.caseFoldPartners
+ * @signature  b.codepointClass.caseFoldPartners(codePoint, unicode)
+ * @since      0.18.19
+ * @related    b.codepointClass.canonicalizeForCase, b.regexLinear.compile
+ *
+ * Every OTHER code point a regular expression treats as the same character as
+ * this one under `i`, given whether the `u` (or `v`) flag applies.
+ *
+ * Use it where the characters to compare against are not a list you can walk —
+ * matching a character against a class of ranges, say. Where you hold both
+ * characters already, `canonicalizeForCase` answers directly and this is not
+ * needed.
+ *
+ * Most partners are the character's own upper and lower forms. Several hundred
+ * are not reachable that way — a micro sign and a Greek mu, a final sigma and an
+ * ordinary one, the title-case digraphs, under `u` a Kelvin sign and a `k`, the
+ * Greek letters carrying a iota subscript beside their capital forms, and two
+ * ligatures that share only the "ST" they upper-case to — and those come from a
+ * table derived from the running platform's own case mappings rather than
+ * transcribed from a Unicode revision.
+ *
+ * @example
+ *   var partners = b.codepointClass.caseFoldPartners;
+ *   partners("σ".codePointAt(0), true);   // sigma → includes the final sigma
+ *   partners("k".codePointAt(0), false);       // → [ "K" ] — not the Kelvin sign
+ */
+function caseFoldPartners(cp, unicode) {
+  var ch = String.fromCodePoint(cp);
+  var target = canonicalizeForCase(cp, unicode);
+  var out = [];
+  var seen = Object.create(null);
+  // Casing REACHES more than it equals. A Kelvin sign lower-cases to a `k` and
+  // is still not a `k` without the `u` flag, so each candidate has to canonicalize
+  // with the character before it counts as the same one.
+  function offer(candidate) {
+    if (!_oneCodePoint(candidate)) return;
+    var other = candidate.codePointAt(0);
+    if (other === cp || seen[other]) return;
+    if (canonicalizeForCase(other, unicode) !== target) return;
+    seen[other] = true;
+    out.push(other);
+  }
+  offer(ch.toLowerCase());
+  offer(ch.toUpperCase());
+  offer(ch.toUpperCase().toLowerCase());
+  var table = unicode ? caseFoldClasses.UNICODE : caseFoldClasses.PLAIN;
+  var extra = table[cp];
+  if (extra !== undefined) {
+    for (var i = 0; i < extra.length; i += 1) {
+      if (extra[i] === cp || seen[extra[i]]) continue;
+      seen[extra[i]] = true;
+      out.push(extra[i]);
+    }
+  }
+  return out;
+}
+
 module.exports = {
+  canonicalizeForCase:     canonicalizeForCase,
+  caseFoldPartners:        caseFoldPartners,
   isForbiddenControlChar:  isForbiddenControlChar,
   firstControlCharOffset:  firstControlCharOffset,
   decodeNumericEntities:   decodeNumericEntities,

package/lib/vendor/blamejs/lib/constants.js

@@ -63,6 +63,84 @@ var BYTES = Object.freeze({
   gib:   function (n) { _validateBytes("gib",   n); return n * 1024 * 1024 * 1024; },
 });
 
+// ---- HTTP status codes ----
+//
+// The registry, named, so a response class is written as what it means rather
+// than as a number a reader has to recognise. Every code RFC 9110 defines, plus
+// the registered ones from the RFCs that extend it (WebDAV 207/208/422-424,
+// early hints 103, 418, 425, 428/429/431 and 451, and 511) — an operator
+// reading a status here should find it whatever RFC put it there.
+//
+// The predicates carry the reasoning the numbers do not. Which statuses may
+// carry a body is a rule stated across RFC 9110 §6.4.1 and §15, and getting it
+// wrong is not cosmetic: destroying a bodiless response to signal a truncation
+// throws away a response that was already complete.
+var STATUS = Object.freeze({
+  CONTINUE: 100, SWITCHING_PROTOCOLS: 101, PROCESSING: 102, EARLY_HINTS: 103,
+
+  OK: 200, CREATED: 201, ACCEPTED: 202, NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204, RESET_CONTENT: 205, PARTIAL_CONTENT: 206, MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208, IM_USED: 226,
+
+  MULTIPLE_CHOICES: 300, MOVED_PERMANENTLY: 301, FOUND: 302, SEE_OTHER: 303,
+  NOT_MODIFIED: 304, USE_PROXY: 305, TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+
+  BAD_REQUEST: 400, UNAUTHORIZED: 401, PAYMENT_REQUIRED: 402, FORBIDDEN: 403,
+  NOT_FOUND: 404, METHOD_NOT_ALLOWED: 405, NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407, REQUEST_TIMEOUT: 408, CONFLICT: 409,
+  GONE: 410, LENGTH_REQUIRED: 411, PRECONDITION_FAILED: 412,
+  CONTENT_TOO_LARGE: 413, URI_TOO_LONG: 414, UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416, EXPECTATION_FAILED: 417, IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421, UNPROCESSABLE_CONTENT: 422, LOCKED: 423,
+  FAILED_DEPENDENCY: 424, TOO_EARLY: 425, UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428, TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431, UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+
+  INTERNAL_SERVER_ERROR: 500, NOT_IMPLEMENTED: 501, BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505, VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507, LOOP_DETECTED: 508, NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511,
+});
+
+// A fraction is not a status even when it lands inside a band: `200.5` is not a
+// success, and saying it is lets a number arrived at by arithmetic or read from
+// configuration pass here and be refused later by the socket, with the handler
+// already run.
+//
+// Being OUTSIDE 100-599 is answered rather than refused, because callers reach
+// these with a status they did not choose. `b.webhook` reports on a delivery
+// whose transport failed with `statusCode` defaulted to 0 and asks whether that
+// was a success; the truthful answer is no, and throwing there would turn a
+// failed delivery into a crash.
+function _validateStatus(name, n) {
+  if (typeof n !== "number" || !isFinite(n) || Math.floor(n) !== n) {
+    throw new TypeError("C.HTTP." + name + ": status must be a whole number, got " +
+      (typeof n) + " " + JSON.stringify(n));
+  }
+}
+
+var HTTP = Object.freeze({
+  STATUS: STATUS,
+
+  informational: function (n) { _validateStatus("informational", n); return n >= 100 && n < 200; },
+  success:       function (n) { _validateStatus("success", n);       return n >= 200 && n < 300; },
+  redirect:      function (n) { _validateStatus("redirect", n);      return n >= 300 && n < 400; },
+  clientError:   function (n) { _validateStatus("clientError", n);   return n >= 400 && n < 500; },
+  serverError:   function (n) { _validateStatus("serverError", n);   return n >= 500 && n < 600; },
+
+  // Carries no body, whatever the handler writes: every 1xx, and 204, 205 and
+  // 304. RFC 9110 §15.3.5 / §15.3.6 / §15.4.5. A response to HEAD is bodiless
+  // too, but that is a property of the request rather than the status, so the
+  // caller answers for it.
+  bodiless: function (n) {
+    _validateStatus("bodiless", n);
+    return (n >= 100 && n < 200) || n === STATUS.NO_CONTENT ||
+           n === STATUS.RESET_CONTENT || n === STATUS.NOT_MODIFIED;
+  },
+});
+
 // ---- Crypto envelope versioning ----
 // Every encrypted blob starts with a 4-byte header that identifies the
 // algorithms used. This enables algorithm agility — any component can
@@ -266,6 +344,7 @@ module.exports = {
   version:                pkg.version,
   TIME:                   TIME,
   BYTES:                  BYTES,
+  HTTP:                   HTTP,
   ENVELOPE_MAGIC:         ENVELOPE_MAGIC,
   ENVELOPE_FIXED_INFO_LABEL: ENVELOPE_FIXED_INFO_LABEL,
   CREDENTIAL_MAGIC:       CREDENTIAL_MAGIC,