@keymanapp/common-types 17.0.85-alpha → 17.0.87-alpha

package/src/kpj/kpj-file.ts

@@ -1,52 +0,0 @@
-/*
- * 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

@@ -1,34 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,53 +0,0 @@
-// .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

@@ -1,80 +0,0 @@
-//
-// 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
-];