@keymanapp/common-types 17.0.85-alpha

package/src/kpj/kpj-file.ts

@@ -0,0 +1,52 @@
+/*
+ * Keyman Developer Project File
+ */
+
+
+// These interfaces match XML read by xml2js. Use `KeymanDeveloperProject`
+// returned by `KPJFileReader.transform()` for all processing.
+
+export interface KPJFile {
+  KeymanDeveloperProject: KPJFileProject;
+}
+
+export interface KPJFileProject {
+  Options?: KPJFileOptions;   // Required
+  Files?: KPJFileFiles;       // Required in 1.0, optional and always ignored in 2.0
+};
+
+export interface KPJFileOptions {
+  BuildPath?: string;                         // default '' in 1.0, '$PROJECTPATH/build' in 2.0
+  SourcePath?: string;                        // default '' in 1.0, '$PROJECTPATH/source' in 2.0
+  CompilerWarningsAsErrors?: string;          // default False
+  WarnDeprecatedCode?: string;                // default True
+  CheckFilenameConventions?: string;          // default True
+  ProjectType?: 'keyboard' | 'lexicalmodel';  // default 'keyboard'
+  Version?: '1.0' | '2.0';                    // default 1.0
+};
+
+export interface KPJFileFiles {
+  File?: KPJFileFile[];
+};
+
+export interface KPJFileFile {
+  ID?: string;
+  Filename?: string;
+  Filepath?: string;
+  FileVersion?: string;
+  FileType?: string;
+  Details?: KPJFileFileDetail_Kmn & KPJFileFileDetail_Kps;
+  ParentFileID?: string;
+};
+
+export interface KPJFileFileDetail_Kmn {
+  Name?: string;
+  Copyright?: string;
+  Message?: string;
+};
+
+export interface KPJFileFileDetail_Kps {
+  Name?: string;
+  Copyright?: string;
+  Version?: string;
+};

package/src/kvk/kvk-file-reader.ts

@@ -0,0 +1,34 @@
+import KVKFile, { BUILDER_KVK_FILE, BUILDER_KVK_HEADER_IDENTIFIER, BUILDER_KVK_HEADER_VERSION } from "./kvk-file.js";
+import { VisualKeyboard, VisualKeyboardKey } from "./visual-keyboard.js";
+
+export default class KvkFileReader {
+  public read(source: Uint8Array): VisualKeyboard {
+    let binary: BUILDER_KVK_FILE;
+    let kvk = new KVKFile();
+    binary = kvk.KVK_FILE.fromBuffer(source);
+    if(binary.header.identifier != BUILDER_KVK_HEADER_IDENTIFIER ||
+        binary.header.version != BUILDER_KVK_HEADER_VERSION) {
+      return null;
+    }
+    let result = new VisualKeyboard();
+    result.header.version = binary.header.version;
+    result.header.flags = binary.header.flags;
+    result.header.associatedKeyboard = binary.header.associatedKeyboard.str;
+    result.header.ansiFont.color = binary.header.ansiFont.color;
+    result.header.ansiFont.name = binary.header.ansiFont.name.str;
+    result.header.ansiFont.size = binary.header.ansiFont.size;
+    result.header.unicodeFont.color = binary.header.unicodeFont.color;
+    result.header.unicodeFont.name = binary.header.unicodeFont.name.str;
+    result.header.unicodeFont.size = binary.header.unicodeFont.size;
+    for(let binaryKey of binary.keys) {
+      let key: VisualKeyboardKey = {
+        flags: binaryKey.flags,
+        vkey: binaryKey.vkey,
+        shift: binaryKey.shift,
+        text: binaryKey.text.str
+      };
+      result.keys.push(key);
+    }
+    return result;
+  }
+};

package/src/kvk/kvk-file-writer.ts

@@ -0,0 +1,72 @@
+import KVKFile, { BUILDER_KVK_FILE, BUILDER_KVK_HEADER_IDENTIFIER, BUILDER_KVK_HEADER_VERSION, BUILDER_KVK_KEY, BUILDER_KVK_STRING } from "./kvk-file.js";
+import { VisualKeyboard } from "./visual-keyboard.js";
+
+export default class KvkFileWriter {
+  /**
+   * Writes the visual keyboard to a binary .kvk format byte array.
+   * @param source VisualKeyboard
+   * @returns Uint8Array, the .kvk file
+   */
+  write(source: VisualKeyboard): Uint8Array {
+    const binary = this.build(source);
+    const kvk = new KVKFile();
+    const file: Uint8Array = new Uint8Array(kvk.KVK_FILE.size(binary));
+    const data = kvk.KVK_FILE.toBuffer(binary);
+    file.set(data, 0);
+    return file;
+  }
+
+  private build(source: VisualKeyboard) {
+    const binary: BUILDER_KVK_FILE = {
+      header: {
+        identifier: BUILDER_KVK_HEADER_IDENTIFIER,
+        version: BUILDER_KVK_HEADER_VERSION,
+        associatedKeyboard: {len:0,str:''},
+        flags: source.header.flags,
+        ansiFont:{
+          color: source.header.ansiFont.color,
+          size: source.header.ansiFont.size,
+          name: {len:0,str:''}
+        },
+        unicodeFont:{
+          color: source.header.unicodeFont.color,
+          size: source.header.unicodeFont.size,
+          name: {len:0,str:''}
+        },
+      },
+      keyCount: source.keys.length,
+      keys:[]
+    };
+
+    this.setString(binary.header.associatedKeyboard, source.header.associatedKeyboard);
+    this.setString(binary.header.ansiFont.name, source.header.ansiFont.name);
+    this.setString(binary.header.unicodeFont.name, source.header.unicodeFont.name);
+
+    for(let sourceKey of source.keys) {
+      const binaryKey: BUILDER_KVK_KEY = {
+        flags: sourceKey.flags,
+        vkey: sourceKey.vkey,
+        shift: sourceKey.shift,
+        text: { len: 0, str: '' },
+        bitmap: 0
+      };
+      this.setString(binaryKey.text, sourceKey.text || '');
+      binary.keys.push(binaryKey);
+    }
+
+    return binary;
+  }
+
+  /**
+   * Fills a kvk string from a source string. Note that the format includes both
+   * a length word and zero termination.
+   *
+   * @param str
+   * @param value
+   * @returns number
+   */
+   private setString(str: BUILDER_KVK_STRING, value: string): void {
+    str.len = value.length + 1;
+    str.str = value;
+  }
+};

package/src/kvk/kvk-file.ts

@@ -0,0 +1,122 @@
+import * as r from 'restructure';
+//
+// Binary backing structures for .kvk format
+// matching VisualKeyboardSaverBinary.pas
+//
+
+export const BUILDER_KVK_HEADER_IDENTIFIER = 0x464B564B; // 'KVKF', little-endian
+export const BUILDER_KVK_HEADER_VERSION    = 0x0600;     // Keyman 6.0
+
+export interface BUILDER_KVK_STRING {
+  len: number;
+  str: string;
+};
+
+export interface BUILDER_KVK_FONT {
+  name: BUILDER_KVK_STRING;       // 0000, variable length
+  size: number;                   // 4 bytes
+  color: number;                  // 4 bytes
+};
+
+export const BUILDER_KVK_FONT_Size = 8; // size of fixed elements of BUILDER_KVK_FONT
+
+export const enum BUILDER_KVK_KEY_FLAGS {
+  kvkkBitmap = 0x01,
+  kvkkUnicode = 0x02
+};
+
+export const enum BUILDER_KVK_SHIFT_STATE {
+  KVKS_NORMAL =  0,
+  KVKS_SHIFT  =  1,
+  KVKS_CTRL   =  2,
+  KVKS_ALT    =  4,
+  KVKS_LCTRL  =  8,
+  KVKS_RCTRL  = 16,
+  KVKS_LALT   = 32,
+  KVKS_RALT   = 64
+};
+
+export interface BUILDER_KVK_KEY {
+  flags: BUILDER_KVK_KEY_FLAGS;   // 0000, 1 byte
+  shift: number;                  // 0001, 2 bytes
+  vkey: number;                   // 0003, 2 bytes
+  text: BUILDER_KVK_STRING;       // 0005, variable length
+  bitmap: number; // always 0     // 4 bytes
+};
+
+export const BUILDER_KVK_KEY_Size = 9; // size of fixed elements of BUILDER_KVK_KEY
+
+export const enum BUILDER_KVK_HEADER_FLAGS {
+  kvkh102 = 0x01,
+  kvkhDisplayUnderlying = 0x02,
+  kvkhUseUnderlying = 0x04,
+  kvkhAltGr = 0x08
+};
+
+export interface BUILDER_KVK_HEADER {
+  identifier: number;             // 0000, 4 bytes
+  version: number;                // 0004, 4 bytes
+  flags: BUILDER_KVK_HEADER_FLAGS;            // 0008, 1 byte
+  associatedKeyboard: BUILDER_KVK_STRING;     // 0009, variable length
+  ansiFont: BUILDER_KVK_FONT;     // variable length
+  unicodeFont: BUILDER_KVK_FONT;  // variable length
+};
+
+export const BUILDER_KVK_HEADER_Size = 9 + BUILDER_KVK_FONT_Size + BUILDER_KVK_FONT_Size; // size of fixed elements of BUILDER_KVK_HEADER
+
+export interface BUILDER_KVK_FILE {
+  header: BUILDER_KVK_HEADER;     // variable length
+  keyCount: number;               // 4 bytes
+  keys: BUILDER_KVK_KEY[];        // variable length
+};
+
+export default class KVKFile {
+  public KVK_HEADER: any;
+  public KVK_KEY: any;
+  public KVK_KEYS: any;
+  public KVK_FONT: any;
+  public KVK_FILE: any;
+  public KVK_STRING: any;
+
+  constructor() {
+    //
+    // Binary restructure definitions matching VisualKeyboardSaverBinary.pas
+    // TODO: move binaries to separate kvk-file.ts
+    //
+
+    this.KVK_STRING = new r.Struct({
+      len: r.int16le,
+      str: new r.String(null, 'utf16le')
+    });
+
+    this.KVK_FONT = new r.Struct({
+      name: this.KVK_STRING,
+      size: r.int32le,
+      color: r.uint32le
+    });
+
+    this.KVK_KEY = new r.Struct({
+      flags: r.uint8,
+      shift: r.uint16le,
+      vkey: r.uint16le,
+      text: this.KVK_STRING,
+      bitmap: r.uint32le // always 00 00 00 00 for now
+    });
+
+    this.KVK_HEADER = new r.Struct({
+      identifier: r.uint32le,   // KVKF
+      version: r.uint32le,      // 0x0600
+      flags: r.uint8,
+      associatedKeyboard: this.KVK_STRING,
+      ansiFont: this.KVK_FONT,
+      unicodeFont: this.KVK_FONT
+    });
+
+    this.KVK_FILE = new r.Struct({
+      header: this.KVK_HEADER,
+      keyCount: r.uint32le,
+      keys: new r.Array(this.KVK_KEY, 'keyCount')
+    });
+
+  }
+};

package/src/kvk/kvks-file-reader.ts

@@ -0,0 +1,164 @@
+import * as xml2js from 'xml2js';
+import KVKSourceFile from './kvks-file.js';
+import { default as AjvModule } from 'ajv';
+const Ajv = AjvModule.default; // The actual expected Ajv type.
+import { boxXmlArray } from '../util/util.js';
+import { VisualKeyboard, VisualKeyboardHeaderFlags, VisualKeyboardKey, VisualKeyboardKeyFlags, VisualKeyboardLegalShiftStates, VisualKeyboardShiftState } from './visual-keyboard.js';
+import { USVirtualKeyCodes } from '../consts/virtual-key-constants.js';
+import { BUILDER_KVK_HEADER_VERSION } from './kvk-file.js';
+
+export enum KVKSParseErrorType { invalidVkey };
+export class KVKSParseError extends Error {
+  public type: KVKSParseErrorType;
+  public vkey: string;
+};
+
+export default class KVKSFileReader {
+  public read(file: Uint8Array): KVKSourceFile {
+    let source: KVKSourceFile;
+
+    const parser = new xml2js.Parser({
+      explicitArray: false,
+      mergeAttrs: false,
+      includeWhiteChars: true,
+      normalize: false,
+      emptyTag: {} as any
+      // Why "as any"? xml2js is broken:
+      // https://github.com/Leonidas-from-XIV/node-xml2js/issues/648 means
+      // that an old version of `emptyTag` is used which doesn't support
+      // functions, but DefinitelyTyped is requiring use of function or a
+      // string. See also notes at
+      // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/59259#issuecomment-1254405470
+      // An alternative fix would be to pull xml2js directly from github
+      // rather than using the version tagged on npmjs.com.
+    });
+
+    parser.parseString(file, (e: unknown, r: unknown) => { source = r as KVKSourceFile });
+    source = this.boxArrays(source);
+    this.cleanupUnderscore('visualkeyboard', source.visualkeyboard);
+    return source;
+  }
+
+  /**
+   * The only element that allows spaces is <key>. Remove
+   * all other empty whitespace-only values.
+   * @param root
+   * @param source
+   */
+  private cleanupUnderscore(root: string, source: any) {
+    if(root != 'key') {
+      if(source?.['_']?.trim() === '') {
+        delete source['_'];
+      }
+    }
+
+    for(let key of Object.keys(source)) {
+      if(Array.isArray(source[key])) {
+        for(let item of source[key]) {
+          if(typeof(item) === 'object') {
+            this.cleanupUnderscore(key, item);
+          }
+        }
+      } else if(typeof source[key] === 'object') {
+        this.cleanupUnderscore(key, source[key]);
+      }
+    }
+  }
+
+  public validate(source: KVKSourceFile, schemaBuffer: Buffer): void {
+    const schema = JSON.parse(schemaBuffer.toString('utf8'));
+    const ajv = new Ajv();
+    if(!ajv.validate(schema, source)) {
+      throw new Error(ajv.errorsText());
+    }
+  }
+
+  public transform(source: KVKSourceFile, errors?: KVKSParseError[]): VisualKeyboard {
+    // NOTE: at this point, the xml should have been validated
+    // and matched the schema result so we can assume properties exist
+    let result: VisualKeyboard = {
+      header: {
+        version: BUILDER_KVK_HEADER_VERSION,
+        flags: 0,
+        ansiFont: { name: "Arial", size: -12, color: 0xFF000008 }, // TODO-LDML: consider defaults
+        unicodeFont: { name: "Arial", size: -12, color: 0xFF000008 }, // TODO-LDML: consider defaults
+        associatedKeyboard: source.visualkeyboard?.header?.kbdname,
+        underlyingLayout: source.visualkeyboard?.header?.layout,
+      },
+      keys: []
+    };
+
+    if(source.visualkeyboard?.header?.flags?.displayunderlying !== undefined) {
+      result.header.flags |= VisualKeyboardHeaderFlags.kvkhDisplayUnderlying;
+    }
+    if(source.visualkeyboard?.header?.flags?.key102 !== undefined) {
+      result.header.flags |= VisualKeyboardHeaderFlags.kvkh102;
+    }
+    if(source.visualkeyboard?.header?.flags?.usealtgr !== undefined) {
+      result.header.flags |= VisualKeyboardHeaderFlags.kvkhAltGr;
+    }
+    if(source.visualkeyboard?.header?.flags?.useunderlying !== undefined) {
+      result.header.flags |= VisualKeyboardHeaderFlags.kvkhUseUnderlying;
+    }
+
+    for(let encoding of source.visualkeyboard.encoding) {
+      let isUnicode = (encoding.$?.name == 'unicode'),
+        font = isUnicode ? result.header.unicodeFont : result.header.ansiFont;
+      font.name = encoding.$?.fontname;
+      font.size = parseInt(encoding.$?.fontsize,10);
+      for(let layer of encoding.layer) {
+        let shift = this.kvksShiftToKvkShift(layer.$?.shift);
+        for(let sourceKey of layer.key) {
+          let vkey = (USVirtualKeyCodes as any)[sourceKey.$?.vkey];
+          if(!vkey) {
+            if(errors) {
+              let e = new KVKSParseError();
+              e.type = KVKSParseErrorType.invalidVkey;
+              e.vkey = sourceKey.$?.vkey;
+              errors.push(e);
+            }
+            continue;
+          }
+          let key: VisualKeyboardKey = {
+            flags: isUnicode ? VisualKeyboardKeyFlags.kvkkUnicode : 0, // TODO-LDML: bitmap support
+            shift: shift,
+            text: sourceKey._ ?? '',
+            vkey: vkey
+          }
+          result.keys.push(key);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * xml2js will not place single-entry objects into arrays.
+   * Easiest way to fix this is to box them ourselves as needed
+   * @param source KVKSourceFile
+   */
+  private boxArrays(source: KVKSourceFile) {
+    boxXmlArray(source.visualkeyboard, 'encoding');
+    for(let encoding of source.visualkeyboard.encoding) {
+      boxXmlArray(encoding, 'layer');
+      for(let layer of encoding.layer) {
+        boxXmlArray(layer, 'key');
+      }
+    }
+    return source;
+  }
+
+
+  public kvksShiftToKvkShift(shift: string): VisualKeyboardShiftState {
+    shift = shift.toUpperCase();
+
+    // TODO-LDML(lowpri): make a map of this?
+    for(let state of VisualKeyboardLegalShiftStates) {
+      if(state.name == shift) {
+        return state.shift;
+      }
+    }
+    return 0;
+  }
+}

package/src/kvk/kvks-file-writer.ts

@@ -0,0 +1,113 @@
+import * as xml2js from 'xml2js';
+import KVKSourceFile, { KVKSEncoding, KVKSFlags, KVKSKey, KVKSLayer } from './kvks-file.js';
+import { VisualKeyboard, VisualKeyboardHeaderFlags, VisualKeyboardKeyFlags, VisualKeyboardLegalShiftStates, VisualKeyboardShiftState } from './visual-keyboard.js';
+import { USVirtualKeyCodes } from '../consts/virtual-key-constants.js';
+
+export default class KVKSFileWriter {
+  public write(vk: VisualKeyboard): string {
+
+    const builder = new xml2js.Builder({
+      allowSurrogateChars: true,
+      attrkey: '$',
+      charkey: '_',
+      xmldec: {
+        version: '1.0',
+        encoding: 'UTF-8',
+        standalone: true
+      }
+    })
+
+    let flags: KVKSFlags = {};
+    if(vk.header.flags & VisualKeyboardHeaderFlags.kvkhDisplayUnderlying) {
+      flags.displayunderlying = '';
+    }
+    if(vk.header.flags & VisualKeyboardHeaderFlags.kvkh102) {
+      flags.key102 = '';
+    }
+    if(vk.header.flags & VisualKeyboardHeaderFlags.kvkhAltGr) {
+      flags.usealtgr = '';
+    }
+    if(vk.header.flags & VisualKeyboardHeaderFlags.kvkhUseUnderlying) {
+      flags.useunderlying = '';
+    }
+
+
+
+    let kvks: KVKSourceFile = {
+      visualkeyboard: {
+        header: {
+          version: '10.0',
+          kbdname: vk.header.associatedKeyboard,
+          flags: flags,
+        },
+        encoding: []
+      }
+    };
+
+    if(vk.header.underlyingLayout) kvks.visualkeyboard.header.layout = vk.header.underlyingLayout;
+
+    let encodings: {ansi: {o: KVKSEncoding, l: {[name:string]:KVKSLayer}}, unicode: {o: KVKSEncoding, l: {[name:string]:KVKSLayer}}} = {ansi:null,unicode:null};
+
+    for(let key of vk.keys) {
+      const encoding = key.flags & VisualKeyboardKeyFlags.kvkkUnicode ? 'unicode' : 'ansi';
+      const shift = this.kvkShiftToKvksShift(key.shift);
+
+      if(!encodings[encoding]) {
+        encodings[encoding] = {
+          o: {
+            layer: [],
+            $: {name: encoding,
+            fontname: encoding == 'ansi' ? vk.header.ansiFont.name : vk.header.unicodeFont.name,
+            fontsize: (encoding == 'ansi' ? vk.header.ansiFont.size : vk.header.unicodeFont.size).toString(),
+            },
+          },
+          l: {}
+        };
+        kvks.visualkeyboard.encoding.push(encodings[encoding].o);
+      }
+      let e = encodings[encoding];
+      if(!e.l[shift]) {
+        e.l[shift] = {
+          key: [],
+          $: {shift: shift},
+        };
+        e.o.layer.push(e.l[shift]);
+      }
+      let l = e.l[shift];
+
+      // TODO-LDML: map
+      let vkeyName = '';
+      for(let vkey of Object.keys(USVirtualKeyCodes)) {
+        if((USVirtualKeyCodes as any)[vkey] == key.vkey) {
+          vkeyName = vkey;
+          break;
+        }
+      }
+
+      if(vkeyName == '') {
+        //TODO-LDML: warn
+        continue;
+      }
+      let k: KVKSKey = {
+        $: {vkey: vkeyName},
+        _: key.text,
+      }
+
+      l.key.push(k);
+    }
+
+    // console.dir(kvks, {depth:8});
+    let result = builder.buildObject(kvks);
+    return result; //Uint8Array.from(result);
+  }
+
+  public kvkShiftToKvksShift(shift: VisualKeyboardShiftState): string {
+    // TODO-LDML(lowpri): make a map of this?
+    for(let state of VisualKeyboardLegalShiftStates) {
+      if(state.shift == shift) {
+        return state.name;
+      }
+    }
+    return '';
+  }
+}

package/src/kvk/kvks-file.ts

@@ -0,0 +1,53 @@
+// .kvks xml format
+// See VisualKeyboardLoaderXML.pas, not the same as VisualKeyboardImportXML.pas!
+
+export default interface KVKSourceFile {
+  /**
+   * <visualkeyboard> -- the root element.
+   */
+  visualkeyboard: KVKSVisualKeyboard;
+}
+
+export interface KVKSVisualKeyboard {
+  header?: KVKSHeader;
+  encoding?: KVKSEncoding[];
+};
+
+export interface KVKSHeader {
+  version?: string;
+  kbdname?: string;
+  flags?: KVKSFlags;
+  layout?: string;
+};
+
+export interface KVKSFlags {
+  key102?: string;
+  displayunderlying?: string;
+  useunderlying?: string;
+  usealtgr?: string;
+};
+
+export interface KVKSEncoding {
+  $?: {
+    name?: string;
+    fontname?: string;
+    fontsize?: string;
+  };
+  layer?: KVKSLayer[];
+};
+
+export interface KVKSLayer {
+  $?: {
+    shift?: string;
+  };
+  key?: KVKSKey[];
+};
+
+export interface KVKSKey {
+  $?: {
+    vkey?: string;
+  }
+  bitmap?: string;
+  _?: string;
+};
+

package/src/kvk/visual-keyboard.ts

@@ -0,0 +1,80 @@
+//
+// Visual Keyboard in-memory data
+//
+// Corresponds to .kvk / .kvks file data
+//
+
+import { BUILDER_KVK_SHIFT_STATE, BUILDER_KVK_HEADER_FLAGS, BUILDER_KVK_KEY_FLAGS } from "./kvk-file.js";
+
+export class VisualKeyboard {
+  header: VisualKeyboardHeader = {flags: 0, ansiFont:{}, unicodeFont:{}, underlyingLayout: undefined};
+  keys: VisualKeyboardKey[] = [];
+};
+
+export { BUILDER_KVK_HEADER_FLAGS as VisualKeyboardHeaderFlags } from "./kvk-file.js";
+
+export class VisualKeyboardHeader {
+  version?: number;                      // 0x0600
+  flags: BUILDER_KVK_HEADER_FLAGS;
+  associatedKeyboard?: string;
+  ansiFont: VisualKeyboardFont;          // generally unused
+  unicodeFont: VisualKeyboardFont;
+  underlyingLayout?: string;
+};
+
+export class VisualKeyboardFont {
+  name?: string;
+  size?: number;
+  color?: number; // unused
+};
+
+export { BUILDER_KVK_KEY_FLAGS as VisualKeyboardKeyFlags } from "./kvk-file.js";
+
+export { BUILDER_KVK_SHIFT_STATE as VisualKeyboardShiftState } from "./kvk-file.js";
+
+export class VisualKeyboardKey {
+  flags?: BUILDER_KVK_KEY_FLAGS;
+  shift?: BUILDER_KVK_SHIFT_STATE;
+  vkey?: number;
+  text?: string;
+  //bitmap: bitmap-image, unsupported in ldml keyboards; may include for round-tripabilty?
+};
+
+interface VisualKeyboardLegalShiftState {
+  desc: string;
+  name: string;
+  shift: number;
+  vkeys: number[];
+};
+
+import { BUILDER_KVK_SHIFT_STATE as ss } from "./kvk-file.js";
+import { USVirtualKeyCodes as vk } from "../consts/virtual-key-constants.js";
+
+export const VisualKeyboardLegalShiftStates: VisualKeyboardLegalShiftState[] = [
+  {desc: 'Unshifted',                  name: '',      shift: ss.KVKS_NORMAL, vkeys: []},    //1
+
+  {desc: 'Shift',                      name: 'S',     shift: ss.KVKS_SHIFT, vkeys: [vk.K_SHIFT]},
+  {desc: 'Ctrl',                       name: 'C',     shift: ss.KVKS_CTRL, vkeys: [vk.K_CONTROL]},
+  {desc: 'Alt',                        name: 'A',     shift: ss.KVKS_ALT, vkeys: [vk.K_ALT]},
+  {desc: 'Shift+Ctrl',                 name: 'SC',    shift: ss.KVKS_SHIFT | ss.KVKS_CTRL, vkeys: [vk.K_SHIFT,vk.K_CONTROL]},
+  {desc: 'Shift+Alt',                  name: 'SA',    shift: ss.KVKS_SHIFT | ss.KVKS_ALT, vkeys: [vk.K_SHIFT,vk.K_ALT]},
+  {desc: 'Ctrl+Alt',                   name: 'CA',    shift: ss.KVKS_CTRL | ss.KVKS_ALT, vkeys: [vk.K_CONTROL,vk.K_ALT]},
+  {desc: 'Shift+Ctrl+Alt',             name: 'SCA',   shift: ss.KVKS_SHIFT | ss.KVKS_CTRL | ss.KVKS_ALT, vkeys: [vk.K_SHIFT,vk.K_CONTROL,vk.K_ALT]},  //7
+
+  {desc: 'Left Ctrl',                  name: 'LC',    shift: ss.KVKS_LCTRL, vkeys: [vk.K_LCONTROL]},
+  {desc: 'Right Ctrl',                 name: 'RC',    shift: ss.KVKS_RCTRL, vkeys: [vk.K_RCONTROL]},
+  {desc: 'Left Alt',                   name: 'LA',    shift: ss.KVKS_LALT, vkeys: [vk.K_LALT]},
+  {desc: 'Right Alt',                  name: 'RA',    shift: ss.KVKS_RALT, vkeys: [vk.K_RALT]},
+  {desc: 'Shift+Left Ctrl',            name: 'SLC',   shift: ss.KVKS_SHIFT | ss.KVKS_LCTRL, vkeys: [vk.K_SHIFT,vk.K_LCONTROL]},
+  {desc: 'Shift+Right Ctrl',           name: 'SRC',   shift: ss.KVKS_SHIFT | ss.KVKS_RCTRL, vkeys: [vk.K_SHIFT,vk.K_RCONTROL]},
+  {desc: 'Shift+Left Alt',             name: 'SLA',   shift: ss.KVKS_SHIFT | ss.KVKS_LALT, vkeys: [vk.K_SHIFT,vk.K_LALT]},
+  {desc: 'Shift+Right Alt',            name: 'SRA',   shift: ss.KVKS_SHIFT | ss.KVKS_RALT, vkeys: [vk.K_SHIFT,vk.K_RALT]},
+  {desc: 'Left Ctrl+Left Alt',         name: 'LCLA',  shift: ss.KVKS_LCTRL | ss.KVKS_LALT, vkeys: [vk.K_LCONTROL,vk.K_LALT]},
+  {desc: 'Left Ctrl+Right Alt',        name: 'LCRA',  shift: ss.KVKS_LCTRL | ss.KVKS_RALT, vkeys: [vk.K_LCONTROL,vk.K_RALT]},
+  {desc: 'Right Ctrl+Left Alt',        name: 'RCLA',  shift: ss.KVKS_RCTRL | ss.KVKS_LALT, vkeys: [vk.K_RCONTROL,vk.K_LALT]},
+  {desc: 'Right Ctrl+Right Alt',       name: 'RCRA',  shift: ss.KVKS_RCTRL | ss.KVKS_RALT, vkeys: [vk.K_RCONTROL,vk.K_RALT]},
+  {desc: 'Shift+Left Ctrl+Left Alt',   name: 'SLCLA', shift: ss.KVKS_SHIFT | ss.KVKS_LCTRL | ss.KVKS_LALT, vkeys: [vk.K_SHIFT, vk.K_LCONTROL,vk.K_LALT]},
+  {desc: 'Shift+Left Ctrl+Right Alt',  name: 'SLCRA', shift: ss.KVKS_SHIFT | ss.KVKS_LCTRL | ss.KVKS_RALT, vkeys: [vk.K_SHIFT, vk.K_LCONTROL,vk.K_RALT]},
+  {desc: 'Shift+Right Ctrl+Left Alt',  name: 'SRCLA', shift: ss.KVKS_SHIFT | ss.KVKS_RCTRL | ss.KVKS_LALT, vkeys: [vk.K_SHIFT, vk.K_RCONTROL,vk.K_LALT]},
+  {desc: 'Shift+Right Ctrl+Right Alt', name: 'SRCRA', shift: ss.KVKS_SHIFT | ss.KVKS_RCTRL | ss.KVKS_RALT, vkeys: [vk.K_SHIFT, vk.K_RCONTROL,vk.K_RALT]},  //16
+];