signify-ts 0.2.1 → 0.3.0-rc2

package/dist/keri/core/httping.d.ts

@@ -1,6 +1,8 @@
-import { Signer } from './signer';
-import { Cigar } from './cigar';
-import { Siger } from './siger';
+import { Signer } from './signer.ts';
+import { Cigar } from './cigar.ts';
+import { Siger } from './siger.ts';
+export declare const HEADER_SIG_INPUT: string;
+export declare const HEADER_SIG_TIME: string;
 export declare function normalize(header: string): string;
 export interface SiginputArgs {
     name: string;
@@ -14,7 +16,12 @@ export interface SiginputArgs {
     keyid?: string;
     context?: string;
 }
-export declare function siginput(signer: Signer, { name, method, path, headers, fields, expires, nonce, alg, keyid, context, }: SiginputArgs): [Map<string, string>, Siger | Cigar];
+/**
+ * Generates, serializes, and signs a Signature-Input HTTP header value as a structured header
+ * @param signer
+ * @param sigInputArgs
+ */
+export declare function siginput(signer: Signer, sigInputArgs: SiginputArgs): [Map<string, string>, Siger | Cigar];
 export declare class Unqualified {
     private readonly _raw;
     constructor(raw: Uint8Array);

package/{src/keri/core/httping.ts → dist/keri/core/httping.js}

@@ -1,53 +1,21 @@
-import {
-    serializeDictionary,
-    Dictionary,
-    parseDictionary,
-    Item,
-    Parameters,
-} from 'structured-headers';
-import { Signer } from './signer';
-import { b } from './core';
-import { Cigar } from './cigar';
-import { nowUTC } from './utils';
-import { Siger } from './siger';
-import Base64 from 'urlsafe-base64';
-import { Buffer } from 'buffer';
-
-export function normalize(header: string) {
+import { serializeDictionary, parseDictionary, } from 'structured-headers';
+import { b } from "./core.js";
+import { nowUTC } from "./utils.js";
+import { encodeBase64Url } from "./base64.js";
+export const HEADER_SIG_INPUT = normalize('Signature-Input');
+export const HEADER_SIG_TIME = normalize('Signify-Timestamp');
+export function normalize(header) {
     return header.trim();
 }
-
-export interface SiginputArgs {
-    name: string;
-    method: string;
-    path: string;
-    headers: Headers;
-    fields: Array<string>;
-    expires?: number;
-    nonce?: string;
-    alg?: string;
-    keyid?: string;
-    context?: string;
-}
-
-export function siginput(
-    signer: Signer,
-    {
-        name,
-        method,
-        path,
-        headers,
-        fields,
-        expires,
-        nonce,
-        alg,
-        keyid,
-        context,
-    }: SiginputArgs
-): [Map<string, string>, Siger | Cigar] {
-    const items = new Array<string>();
-    const ifields = new Array<[string, Map<string, string>]>();
-
+/**
+ * Generates, serializes, and signs a Signature-Input HTTP header value as a structured header
+ * @param signer
+ * @param sigInputArgs
+ */
+export function siginput(signer, sigInputArgs) {
+    const { name, method, path, headers, fields, expires, nonce, alg, keyid, context, } = sigInputArgs;
+    const items = new Array();
+    const ifields = new Array();
     fields.forEach((field) => {
         if (field.startsWith('@')) {
             switch (field) {
@@ -60,19 +28,18 @@ export function siginput(
                     ifields.push([field, new Map()]);
                     break;
             }
-        } else {
-            if (!headers.has(field)) return;
-
+        }
+        else {
+            if (!headers.has(field))
+                return;
             ifields.push([field, new Map()]);
-            const value = normalize(headers.get(field)!);
+            const value = normalize(headers.get(field));
             items.push(`"${field}": ${value}`);
         }
     });
-
-    const nameParams = new Map<string, string | number>();
+    const nameParams = new Map();
     const now = Math.floor(nowUTC().getTime() / 1000);
     nameParams.set('created', now);
-
     const values = [
         `(${ifields.map((field) => field[0]).join(' ')})`,
         `created=${now}`,
@@ -98,90 +65,61 @@ export function siginput(
         nameParams.set('alg', alg);
     }
     const sid = new Map([[name, [ifields, nameParams]]]);
-
     const params = values.join(';');
     items.push(`"@signature-params: ${params}"`);
-
     const ser = items.join('\n');
     const sig = signer.sign(b(ser));
-
     return [
-        new Map<string, string>([
-            ['Signature-Input', `${serializeDictionary(sid as Dictionary)}`],
+        new Map([
+            [HEADER_SIG_INPUT, `${serializeDictionary(sid)}`],
         ]),
         sig,
     ];
 }
-
 export class Unqualified {
-    private readonly _raw: Uint8Array;
-
-    constructor(raw: Uint8Array) {
+    constructor(raw) {
         this._raw = raw;
     }
-
-    get qb64(): string {
-        return Base64.encode(Buffer.from(this._raw));
+    get qb64() {
+        return encodeBase64Url(this._raw);
     }
-
-    get qb64b(): Uint8Array {
+    get qb64b() {
         return b(this.qb64);
     }
 }
-
 export class Inputage {
-    public name: any;
-    public fields: any;
-    public created: any;
-    public expires: any;
-    public nonce: any;
-    public alg: any;
-    public keyid: any;
-    public context: any;
 }
-
-export function desiginput(value: string): Array<Inputage> {
+export function desiginput(value) {
     const sid = parseDictionary(value);
-    const siginputs = new Array<Inputage>();
-
+    const siginputs = new Array();
     sid.forEach((value, key) => {
         const siginput = new Inputage();
         siginput.name = key;
-        let list: Item[];
+        let list;
         let params;
-        [list, params] = value as [Item[], Parameters];
+        [list, params] = value;
         siginput.fields = list.map((item) => item[0]);
-
         if (!params.has('created')) {
-            throw new Error(
-                'missing required `created` field from signature input'
-            );
+            throw new Error('missing required `created` field from signature input');
         }
         siginput.created = params.get('created');
-
         if (params.has('expires')) {
             siginput.expires = params.get('expires');
         }
-
         if (params.has('nonce')) {
             siginput.nonce = params.get('nonce');
         }
-
         if (params.has('alg')) {
             siginput.alg = params.get('alg');
         }
-
         if (params.has('keyid')) {
             siginput.keyid = params.get('keyid');
         }
-
         if (params.has('context')) {
             siginput.context = params.get('context');
         }
-
         siginputs.push(siginput);
     });
-
     return siginputs;
 }
 /** Parse start, end and total from HTTP Content-Range header value
@@ -189,21 +127,18 @@ export function desiginput(value: string): Array<Inputage> {
  * @param {string} typ - type of range, e.g. "aids"
  * @returns {start: number, end: number, total: number} - object with start, end and total properties
  */
-export function parseRangeHeaders(
-    header: string | null,
-    typ: string
-): { start: number; end: number; total: number } {
+export function parseRangeHeaders(header, typ) {
     if (header !== null) {
         const data = header.replace(`${typ} `, '');
         const values = data.split('/');
         const rng = values[0].split('-');
-
         return {
             start: parseInt(rng[0]),
             end: parseInt(rng[1]),
             total: parseInt(values[1]),
         };
-    } else {
+    }
+    else {
         return { start: 0, end: 0, total: 0 };
     }
 }

package/dist/keri/core/indexer.d.ts

@@ -92,7 +92,7 @@ export declare class Indexer {
     get index(): number;
     get ondex(): number | undefined;
     get qb64(): string;
-    get qb64b(): Uint8Array;
+    get qb64b(): Uint8Array<ArrayBufferLike>;
     private _infil;
     _exfil(qb64: string): void;
 }

package/dist/keri/core/indexer.js

@@ -0,0 +1,407 @@
+import { EmptyMaterialError } from "./kering.js";
+import { b, b64ToInt, d, intToB64, readInt } from "./core.js";
+import { decodeBase64Url, encodeBase64Url } from "./base64.js";
+export class IndexerCodex {
+    constructor() {
+        this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+        this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+        this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list.
+        this.ECDSA_256r1_Sig = 'E'; // ECDSA secp256r1 sig appears same in both lists if any.
+        this.ECDSA_256r1_Crt_Sig = 'F'; // ECDSA secp256r1 sig appears in current list.
+        this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+        this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+        this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both lists.
+        this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+        this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+        this.ECDSA_256r1_Big_Sig = '2E'; // ECDSA secp256r1 sig appears in both lists.
+        this.ECDSA_256r1_Big_Crt_Sig = '2F'; // ECDSA secp256r1 sig appears in current list only.
+        this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+        this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+    }
+}
+export const IdrDex = new IndexerCodex();
+export class IndexedSigCodex {
+    constructor() {
+        this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+        this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+        this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list.
+        this.ECDSA_256r1_Sig = 'E'; // ECDSA secp256r1 sig appears same in both lists if any.
+        this.ECDSA_256r1_Crt_Sig = 'F'; // ECDSA secp256r1 sig appears in current list.
+        this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+        this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+        this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both lists.
+        this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+        this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+        this.ECDSA_256r1_Big_Sig = '2E'; // ECDSA secp256r1 sig appears in both lists.
+        this.ECDSA_256r1_Big_Crt_Sig = '2F'; // ECDSA secp256r1 sig appears in current list only.
+        this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+        this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+    }
+    has(prop) {
+        const m = new Map(Array.from(Object.entries(this), (v) => [v[1], v[0]]));
+        return m.has(prop);
+    }
+}
+export const IdxSigDex = new IndexedSigCodex();
+export class IndexedCurrentSigCodex {
+    constructor() {
+        this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list only.
+        this.ECDSA_256r1_Crt_Sig = 'F'; // ECDSA secp256r1 sig appears in current list.
+        this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+        this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+        this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+        this.ECDSA_256r1_Big_Crt_Sig = '2F'; // ECDSA secp256r1 sig appears in current list only.
+        this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+    }
+    has(prop) {
+        const m = new Map(Array.from(Object.entries(this), (v) => [v[1], v[0]]));
+        return m.has(prop);
+    }
+}
+export const IdxCrtSigDex = new IndexedCurrentSigCodex();
+export class IndexedBothSigCodex {
+    constructor() {
+        this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+        this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+        this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+        this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both listsy.
+        this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+        this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+    }
+    has(prop) {
+        const m = new Map(Array.from(Object.entries(this), (v) => [v[1], v[0]]));
+        return m.has(prop);
+    }
+}
+export const IdxBthSigDex = new IndexedBothSigCodex();
+export class Xizage {
+    constructor(hs, ss, os, fs, ls) {
+        this.hs = hs;
+        this.ss = ss;
+        this.os = os;
+        this.fs = fs;
+        this.ls = ls;
+    }
+}
+export class Indexer {
+    constructor({ raw = undefined, code = IdrDex.Ed25519_Sig, index = 0, ondex = undefined, qb64b = undefined, qb64 = undefined, qb2 = undefined, }) {
+        this.Codex = IdrDex;
+        this._code = '';
+        this._index = -1;
+        this._raw = new Uint8Array(0);
+        if (raw != undefined) {
+            if (code == undefined) {
+                throw new EmptyMaterialError(`Improper initialization need either (raw and code) or qb64b or qb64 or qb2.`);
+            }
+            if (!Indexer.Sizes.has(code)) {
+                throw new Error(`Unsupported code=${code}.`);
+            }
+            const xizage = Indexer.Sizes.get(code);
+            const os = xizage.os;
+            const fs = xizage.fs;
+            const cs = xizage.hs + xizage.ss;
+            const ms = xizage.ss - xizage.os;
+            if (!Number.isInteger(index) || index < 0 || index > 64 ** ms - 1) {
+                throw new Error(`Invalid index=${index} for code=${code}.`);
+            }
+            if (ondex != undefined &&
+                xizage.os != 0 &&
+                !(ondex >= 0 && ondex <= 64 ** os - 1)) {
+                throw new Error(`Invalid ondex=${ondex} for code=${code}.`);
+            }
+            if (IdxCrtSigDex.has(code) && ondex != undefined) {
+                throw new Error(`Non None ondex=${ondex} for code=${code}.`);
+            }
+            if (IdxBthSigDex.has(code)) {
+                if (ondex == undefined) {
+                    ondex = index;
+                }
+                else {
+                    if (ondex != index && os == 0) {
+                        throw new Error(`Non matching ondex=${ondex} and index=${index} for code=${code}.`);
+                    }
+                }
+            }
+            if (fs == undefined) {
+                throw new Error('variable length unsupported');
+            }
+            // TODO: Don't support this code
+            //  if not fs:  # compute fs from index
+            //       if cs % 4:
+            //           raise InvalidCodeSizeError(f"Whole code size not multiple of 4 for "
+            //                                      f"variable length material. cs={cs}.")
+            //       if os != 0:
+            //           raise InvalidCodeSizeError(f"Non-zero other index size for "
+            //                                      f"variable length material. os={os}.")
+            //       fs = (index * 4) + cs
+            const rawsize = Math.floor(((fs - cs) * 3) / 4);
+            raw = raw.slice(0, rawsize);
+            if (raw.length != rawsize) {
+                throw new Error(`Not enougth raw bytes for code=${code} and index=${index} ,expected ${rawsize} got ${raw.length}.`);
+            }
+            this._code = code;
+            this._index = index;
+            this._ondex = ondex;
+            this._raw = raw;
+        }
+        else if (qb64b != undefined) {
+            const qb64 = d(qb64b);
+            this._exfil(qb64);
+        }
+        else if (qb64 != undefined) {
+            this._exfil(qb64);
+        }
+        else if (qb2 != undefined) {
+            this._bexfil(qb2);
+        }
+        else {
+            throw new EmptyMaterialError(`Improper initialization need either (raw and code and index) or qb64b or qb64 or qb2.`);
+        }
+    }
+    _bexfil(qb2) {
+        throw new Error(`qb2 not yet supported: ${qb2}`);
+    }
+    static _rawSize(code) {
+        const xizage = Indexer.Sizes.get(code);
+        return Math.floor(xizage.fs - ((xizage.hs + xizage.ss) * 3) / 4);
+    }
+    get code() {
+        return this._code;
+    }
+    get raw() {
+        return this._raw;
+    }
+    get index() {
+        return this._index;
+    }
+    get ondex() {
+        return this._ondex;
+    }
+    get qb64() {
+        return this._infil();
+    }
+    get qb64b() {
+        return b(this.qb64);
+    }
+    _infil() {
+        const code = this.code;
+        const index = this.index;
+        const ondex = this.ondex;
+        const raw = this.raw;
+        const ps = (3 - (raw.length % 3)) % 3;
+        const xizage = Indexer.Sizes.get(code);
+        const cs = xizage.hs + xizage.ss;
+        const ms = xizage.ss - xizage.os;
+        // TODO: don't support this code
+        //  if not fs:  # compute fs from index
+        //       if cs % 4:
+        //           raise InvalidCodeSizeError(f"Whole code size not multiple of 4 for "
+        //                                      f"variable length material. cs={cs}.")
+        //       if os != 0:
+        //           raise InvalidCodeSizeError(f"Non-zero other index size for "
+        //                                      f"variable length material. os={os}.")
+        //       fs = (index * 4) + cs
+        if (index < 0 || index > 64 ** ms - 1) {
+            throw new Error(`Invalid index=${index} for code=${code}.`);
+        }
+        if (ondex != undefined &&
+            xizage.os != 0 &&
+            !(ondex >= 0 && ondex <= 64 ** xizage.os - 1)) {
+            throw new Error(`Invalid ondex=${ondex} for os=${xizage.os} and code=${code}.`);
+        }
+        const both = `${code}${intToB64(index, ms)}${intToB64(ondex == undefined ? 0 : ondex, xizage.os)}`;
+        if (both.length != cs) {
+            throw new Error(`Mismatch code size = ${cs} with table = ${both.length}.`);
+        }
+        if (cs % 4 != ps - xizage.ls) {
+            throw new Error(`Invalid code=${both} for converted raw pad size=${ps}.`);
+        }
+        const bytes = new Uint8Array(ps + raw.length);
+        for (let i = 0; i < ps; i++) {
+            bytes[i] = 0;
+        }
+        for (let i = 0; i < raw.length; i++) {
+            const odx = i + ps;
+            bytes[odx] = raw[i];
+        }
+        const full = both + encodeBase64Url(bytes).slice(ps - xizage.ls);
+        if (full.length != xizage.fs) {
+            throw new Error(`Invalid code=${both} for raw size=${raw.length}.`);
+        }
+        return full;
+    }
+    _exfil(qb64) {
+        if (qb64.length == 0) {
+            throw new Error('Empty Material');
+        }
+        const first = qb64[0];
+        if (!Array.from(Indexer.Hards.keys()).includes(first)) {
+            throw new Error(`Unexpected code ${first}`);
+        }
+        const hs = Indexer.Hards.get(first);
+        if (qb64.length < hs) {
+            throw new Error(`Need ${hs - qb64.length} more characters.`);
+        }
+        const hard = qb64.slice(0, hs);
+        if (!Array.from(Indexer.Sizes.keys()).includes(hard)) {
+            throw new Error(`Unsupported code ${hard}`);
+        }
+        const xizage = Indexer.Sizes.get(hard);
+        const cs = xizage.hs + xizage.ss; // both hard + soft code size
+        const ms = xizage.ss - xizage.os;
+        if (qb64.length < cs) {
+            throw new Error(`Need ${cs - qb64.length} more characters.`);
+        }
+        const sindex = qb64.slice(hs, hs + ms);
+        const index = b64ToInt(sindex);
+        const sondex = qb64.slice(hs + ms, hs + ms + xizage.os);
+        let ondex;
+        if (IdxCrtSigDex.has(hard)) {
+            ondex = xizage.os != 0 ? b64ToInt(sondex) : undefined;
+            if (ondex != 0 && ondex != undefined) {
+                throw new Error(`Invalid ondex=${ondex} for code=${hard}.`);
+            }
+            else {
+                ondex = undefined;
+            }
+        }
+        else {
+            ondex = xizage.os != 0 ? b64ToInt(sondex) : index;
+        }
+        if (xizage.fs == undefined) {
+            throw new Error('variable length not supported');
+        }
+        // TODO: support variable length
+        // if not fs:  # compute fs from index which means variable length
+        //     if cs % 4:
+        //         raise ValidationError(f"Whole code size not multiple of 4 for "
+        //                               f"variable length material. cs={cs}.")
+        //     if os != 0:
+        //         raise ValidationError(f"Non-zero other index size for "
+        //                               f"variable length material. os={os}.")
+        //     fs = (index * 4) + cs
+        if (qb64.length < xizage.fs) {
+            throw new Error(`Need ${xizage.fs - qb64.length} more chars.`);
+        }
+        qb64 = qb64.slice(0, xizage.fs);
+        const ps = cs % 4;
+        const pbs = 2 * ps != 0 ? ps : xizage.ls;
+        let raw;
+        if (ps != 0) {
+            const base = new Array(ps + 1).join('A') + qb64.slice(cs);
+            const paw = decodeBase64Url(base); // decode base to leave prepadded raw
+            const pi = readInt(paw.slice(0, ps)); // prepad as int
+            if (pi & (2 ** pbs - 1)) {
+                // masked pad bits non-zero
+                throw new Error(`Non zeroed prepad bits = {pi & (2 ** pbs - 1 ):<06b} in {qb64b[cs:cs+1]}.`);
+            }
+            raw = paw.slice(ps); // strip off ps prepad paw bytes
+        }
+        else {
+            const base = qb64.slice(cs);
+            const paw = decodeBase64Url(base);
+            const li = readInt(paw.slice(0, xizage.ls));
+            if (li != 0) {
+                if (li == 1) {
+                    throw new Error(`Non zeroed lead byte = 0x{li:02x}.`);
+                }
+                else {
+                    throw new Error(`Non zeroed lead bytes = 0x{li:04x}`);
+                }
+            }
+            raw = paw.slice(xizage.ls);
+        }
+        if (raw.length != Math.floor(((qb64.length - cs) * 3) / 4)) {
+            throw new Error(`Improperly qualified material = ${qb64}`);
+        }
+        this._code = hard;
+        this._index = index;
+        this._ondex = ondex;
+        this._raw = new Uint8Array(raw); // must be bytes for crpto opts and immutable not bytearray
+    }
+}
+Indexer.Hards = new Map([
+    ['A', 1],
+    ['B', 1],
+    ['C', 1],
+    ['D', 1],
+    ['E', 1],
+    ['F', 1],
+    ['G', 1],
+    ['H', 1],
+    ['I', 1],
+    ['J', 1],
+    ['K', 1],
+    ['L', 1],
+    ['M', 1],
+    ['N', 1],
+    ['O', 1],
+    ['P', 1],
+    ['Q', 1],
+    ['R', 1],
+    ['S', 1],
+    ['T', 1],
+    ['U', 1],
+    ['V', 1],
+    ['W', 1],
+    ['X', 1],
+    ['Y', 1],
+    ['Z', 1],
+    ['a', 1],
+    ['b', 1],
+    ['c', 1],
+    ['d', 1],
+    ['e', 1],
+    ['f', 1],
+    ['g', 1],
+    ['h', 1],
+    ['i', 1],
+    ['j', 1],
+    ['k', 1],
+    ['l', 1],
+    ['m', 1],
+    ['n', 1],
+    ['o', 1],
+    ['p', 1],
+    ['q', 1],
+    ['r', 1],
+    ['s', 1],
+    ['t', 1],
+    ['u', 1],
+    ['v', 1],
+    ['w', 1],
+    ['x', 1],
+    ['y', 1],
+    ['z', 1],
+    ['0', 2],
+    ['1', 2],
+    ['2', 2],
+    ['3', 2],
+    ['4', 2],
+]);
+Indexer.Sizes = new Map(Object.entries({
+    A: new Xizage(1, 1, 0, 88, 0),
+    B: new Xizage(1, 1, 0, 88, 0),
+    C: new Xizage(1, 1, 0, 88, 0),
+    D: new Xizage(1, 1, 0, 88, 0),
+    E: new Xizage(1, 1, 0, 88, 0),
+    F: new Xizage(1, 1, 0, 88, 0),
+    '0A': new Xizage(2, 2, 1, 156, 0),
+    '0B': new Xizage(2, 2, 1, 156, 0),
+    '2A': new Xizage(2, 4, 2, 92, 0),
+    '2B': new Xizage(2, 4, 2, 92, 0),
+    '2C': new Xizage(2, 4, 2, 92, 0),
+    '2D': new Xizage(2, 4, 2, 92, 0),
+    '2E': new Xizage(2, 4, 2, 92, 0),
+    '2F': new Xizage(2, 4, 2, 92, 0),
+    '3A': new Xizage(2, 6, 3, 160, 0),
+    '3B': new Xizage(2, 6, 3, 160, 0),
+    '0z': new Xizage(2, 2, 0, undefined, 0),
+    '1z': new Xizage(2, 2, 1, 76, 1),
+    '4z': new Xizage(2, 6, 3, 80, 1),
+}));