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

package/src/keyman-touch-layout/keyman-touch-layout-file-writer.ts

@@ -1,84 +0,0 @@
-import { TouchLayoutFile, TouchLayoutPlatform, TouchLayoutKey, TouchLayoutSubKey } from "./keyman-touch-layout-file.js";
-
-export interface TouchLayoutFileWriterOptions {
-  formatted?: boolean;
-};
-
-export class TouchLayoutFileWriter {
-
-  options: TouchLayoutFileWriterOptions;
-
-  constructor(options?: TouchLayoutFileWriterOptions) {
-    this.options = {...options};
-  }
-
-  /**
-   * Writes the touch layout to a .keyman-touch-layout JSON file
-   * @param source TouchLayoutFile
-   * @returns Uint8Array, the .keyman-touch-layout file
-   */
-  write(source: TouchLayoutFile): Uint8Array {
-    const output = JSON.stringify(source, null, this.options?.formatted ? 2 : undefined);
-    const encoder = new TextEncoder();
-    return encoder.encode(output);
-  }
-
-  /**
-   * Compiles the touch layout file into a KeymanWeb-compatible JSON-style
-   * object string. In the future, this may be optimized to remove unnecessary
-   * quoting of property names, and remove unused properties, as this string
-   * is embedded into .js code.
-   * @param source
-   * @returns string
-   */
-  compile(source: TouchLayoutFile): string {
-    // Deep copy the source
-    source = JSON.parse(JSON.stringify(source));
-
-    // Fixup pad, width and sp to string types, as that's what KeymanWeb
-    // currently expects
-
-    const fixupKey = (key: TouchLayoutKey | TouchLayoutSubKey) => {
-      if(Object.hasOwn(key, 'pad')) (key.pad as any) = key.pad.toString();
-      if(Object.hasOwn(key, 'sp')) (key.sp as any) = key.sp.toString();
-      if(Object.hasOwn(key, 'width')) (key.width as any) = key.width.toString();
-    };
-
-    const fixupPlatform = (platform: TouchLayoutPlatform) => {
-      for(let layer of platform.layer) {
-        for(let row of layer.row) {
-          for(let key of row.key) {
-            fixupKey(key);
-            if(key.sk) {
-              for(let sk of key.sk) {
-                fixupKey(sk);
-              }
-            }
-            if(key.multitap) {
-              for(let sk of key.multitap) {
-                fixupKey(sk);
-              }
-            }
-            if(key.flick) {
-              for(let id of Object.keys(key.flick)) {
-                fixupKey((key.flick as any)[id] as TouchLayoutSubKey);
-              }
-            }
-          }
-        }
-      }
-    };
-
-    if(source.desktop) {
-      fixupPlatform(source.desktop);
-    }
-    if(source.phone) {
-      fixupPlatform(source.phone);
-    }
-    if(source.tablet) {
-      fixupPlatform(source.tablet);
-    }
-
-    return JSON.stringify(source, null, this.options?.formatted ? 2 : undefined);
-  }
-};

package/src/keyman-touch-layout/keyman-touch-layout-file.ts

@@ -1,87 +0,0 @@
-//
-// .keyman-touch-layout JSON format
-//
-// Follows /common/schemas/keyman-touch-layout/keyman-touch-layout.spec.json for
-// reading and
-// /common/schemas/keyman-touch-layout/keyman-touch-layout.clean.spec.json for
-// writing
-//
-
-export interface TouchLayoutFile {
-  tablet?: TouchLayoutPlatform;
-  phone?: TouchLayoutPlatform;
-  desktop?: TouchLayoutPlatform;
-};
-
-export type TouchLayoutFont = string;
-export type TouchLayoutFontSize = string;
-export type TouchLayoutDefaultHint = "none"|"dot"|"longpress"|"multitap"|"flick"|"flick-n"|"flick-ne"|"flick-e"|"flick-se"|"flick-s"|"flick-sw"|"flick-w"|"flick-nw";
-
-export interface TouchLayoutPlatform {
-  font?: TouchLayoutFont;
-  fontsize?: TouchLayoutFontSize;
-  layer: TouchLayoutLayer[];
-  displayUnderlying?: boolean;
-  defaultHint: TouchLayoutDefaultHint;
-};
-
-export type TouchLayoutLayerId = string;  // pattern = /^[a-zA-Z0-9_-]+$/
-
-export interface TouchLayoutLayer {
-  id: TouchLayoutLayerId;
-  row: TouchLayoutRow[];
-};
-
-export type TouchLayoutRowId = number;
-
-export interface TouchLayoutRow {
-  id: TouchLayoutRowId;
-  key: TouchLayoutKey[];
-};
-
-type Key_Type = 'T'|'K'|'U'|'t'|'k'|'u';
-type Key_Id = string;
-export type TouchLayoutKeyId = `${Key_Type}_${Key_Id}`; // pattern = /^[TKUtku]_[a-zA-Z0-9_]+$/
-
-export interface TouchLayoutKey {
-  id?: TouchLayoutKeyId;
-  text?: string;
-  layer?: TouchLayoutLayerId;
-  nextlayer?: TouchLayoutLayerId;
-  font?: TouchLayoutFont;
-  fontsize?: TouchLayoutFontSize;
-  sp?: TouchLayoutKeySp;
-  pad?: TouchLayoutKeyPad;
-  width?: TouchLayoutKeyWidth;
-  sk?: TouchLayoutSubKey[];
-  flick?: TouchLayoutFlick;
-  multitap?: TouchLayoutSubKey[];
-  hint?: string;
-};
-
-export enum TouchLayoutKeySp { normal=0, special=1, specialActive=2, deadkey=8, blank=9, spacer=10 };
-export type TouchLayoutKeyPad = number; // 0-100000
-export type TouchLayoutKeyWidth = number; // 0-100000
-
-export interface TouchLayoutSubKey {
-  id: TouchLayoutKeyId;
-  text?: string;
-  layer?: TouchLayoutLayerId;
-  nextlayer?: TouchLayoutLayerId;
-  font?: TouchLayoutFont;
-  fontsize?: TouchLayoutFontSize;
-  sp?: TouchLayoutKeySp;
-  pad?: TouchLayoutKeyPad;
-  width?: TouchLayoutKeyWidth;
-};
-
-export interface TouchLayoutFlick {
-  n?: TouchLayoutSubKey;
-  s?: TouchLayoutSubKey;
-  e?: TouchLayoutSubKey;
-  w?: TouchLayoutSubKey;
-  ne?: TouchLayoutSubKey;
-  nw?: TouchLayoutSubKey;
-  se?: TouchLayoutSubKey;
-  sw?: TouchLayoutSubKey;
-};

package/src/kmx/element-string.ts

@@ -1,79 +0,0 @@
-import { constants } from '@keymanapp/ldml-keyboard-constants';
-import { Strs, StrsItem } from './kmx-plus.js';
-
-export enum ElemElementFlags {
-  none = 0,
-  unicode_set = constants.elem_flags_unicode_set,
-  tertiary_base = constants.elem_flags_tertiary_base,
-  prebase = constants.elem_flags_prebase
-}
-;
-
-export class ElemElement {
-  value: StrsItem; // UnicodeSet or UCS32LE character
-  order: number; // -128 to +127; used only by reorder element values
-  tertiary: number; // -128 to +127; used only by reorder element values
-  flags: ElemElementFlags;
-  isEqual(a: ElemElement) {
-    return a.value === this.value &&
-      a.order === this.order &&
-      a.tertiary === this.tertiary &&
-      a.flags === this.flags;
-  }
-}
-;
-
-export class ElementString extends Array<ElemElement> {
-  constructor(strs: Strs, source: string, order?: string, tertiary?: string, tertiary_base?: string, prebase?: string) {
-    super();
-    //TODO-LDML: full UnicodeSet and parsing
-    if(!source) {
-      return;
-    }
-
-    let items = source.split("");
-
-    let orders: Array<string> = order ? order.split(" ") : [];
-    if(orders.length == 1) {
-      orders = Array<string>(items.length).fill(orders[0]);
-    }
-
-    let tertiaries: Array<string> = tertiary ? tertiary.split(" ") : [];
-    if(tertiaries.length == 1) {
-      tertiaries = Array<string>(items.length).fill(tertiaries[0]);
-    }
-
-    let tertiary_bases: Array<string> = tertiary_base ? tertiary_base.split(" ") : [];
-    if(tertiary_bases.length == 1) {
-      tertiary_bases = Array<string>(items.length).fill(tertiary_bases[0]);
-    }
-
-    let prebases: Array<string> = prebase ? prebase.split(" ") : [];
-    if(prebases.length == 1) {
-      prebases = Array<string>(items.length).fill(prebases[0]);
-    }
-
-    for(let i = 0; i < items.length; i++) {
-      let elem = new ElemElement();
-      elem.value = strs.allocString(items[i]);
-      elem.order = orders.length ? parseInt(orders[i], 10) : 0;
-      elem.tertiary = tertiaries.length ? parseInt(tertiaries[i], 10) : 0;
-      elem.flags = ElemElementFlags.none |
-        (tertiary_bases?.[i] == '1' /* TODO-LDML: or 'true'? */ ? ElemElementFlags.tertiary_base : 0) |
-        (prebases?.[i] == '1' /* TODO-LDML: or 'true'? */ ? ElemElementFlags.prebase : 0);
-      this.push(elem);
-    };
-  }
-  isEqual(a: ElementString): boolean {
-    if (a.length != this.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!this[i].isEqual(a[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-;

package/src/kmx/kmx-builder.ts

@@ -1,287 +0,0 @@
-import * as r from 'restructure';
-import { KMXFile, GROUP, KEY, STORE } from './kmx.js';
-import { KMXPlusFile } from './kmx-plus.js';
-import KMXPlusBuilder from './kmx-plus-builder/kmx-plus-builder.js';
-
-// These type-checking structures are here to ensure that
-// we match the structures from kmx.ts in the generator
-//
-// They are used internally when building a .kmx file
-
-interface BUILDER_COMP_KEYBOARD {
-  dwIdentifier: number;
-  dwFileVersion: number;
-  dwCheckSum: number;
-  KeyboardID: number;
-  IsRegistered: number;
-  version: number;
-
-  cxStoreArray: number;
-  cxGroupArray: number;
-
-  dpStoreArray: number;
-  dpGroupArray: number;
-
-  StartGroup_ANSI: number;
-  StartGroup_Unicode: number;
-
-  dwFlags: number;
-
-  dwHotKey: number;
-
-  dpBitmapOffset: number;
-  dwBitmapSize: number;
-};
-
-interface BUILDER_COMP_KEYBOARD_KMXPLUSINFO {
-  dpKMXPlus: number;
-  dwKMXPlusSize: number;
-};
-
-interface BUILDER_COMP_STORE {
-  dwSystemID: number;
-  dpName: number;
-  dpString: number;
-};
-
-interface BUILDER_COMP_KEY {
-  Key: number;
-  _padding: number;
-  Line: number;
-  ShiftFlags: number;
-  dpOutput: number;
-  dpContext: number;
-};
-
-interface BUILDER_COMP_GROUP {
-  dpName: number;
-  dpKeyArray: number;
-  dpMatch: number;
-  dpNoMatch: number;
-  cxKeyArray: number;
-  fUsingKeys: number;
-};
-
-
-export default class KMXBuilder {
-  file: KMXFile;
-  base_keyboard: number = 0;
-  base_kmxplus: number = 0;
-  comp_header: BUILDER_COMP_KEYBOARD;
-  comp_kmxplus: BUILDER_COMP_KEYBOARD_KMXPLUSINFO;
-  comp_stores: {base: number, store: STORE, obj: BUILDER_COMP_STORE}[] = [];
-  comp_groups: {base: number, group: GROUP, obj: BUILDER_COMP_GROUP, keys: {base: number, key: KEY, obj: BUILDER_COMP_KEY}[]}[] = [];
-  comp_kmxplus_data: Uint8Array;
-  writeDebug: boolean = false;
-
-  constructor(file: KMXFile, writeDebug: boolean) {
-    this.file = file;
-    this.writeDebug = writeDebug;
-  }
-
-  calculateStringOffsetAndSize(string: string, base: number, requireString: boolean = false) {
-    if(string.length == 0 && !requireString) {
-      // Zero length strings take up no space in the file, and
-      // are treated as a 'null string'
-      return [0, base];
-    }
-    return [base, base + string.length * 2 + 2]; // include trailing zero
-  }
-
-  private build() {
-    this.base_keyboard = 0;
-    this.base_kmxplus = 0;
-
-    //  Header
-
-    this.comp_header = {
-      dwIdentifier: KMXFile.FILEID_COMPILED,
-      dwFileVersion: KMXFile.VERSION_160,
-      dwCheckSum: 0,  // Deprecated in Keyman 16.0
-      KeyboardID: 0,
-      IsRegistered: 1,
-      version: 0,
-      cxStoreArray: 0,
-      cxGroupArray: 0,
-      dpStoreArray: 0,
-      dpGroupArray: 0,
-      StartGroup_ANSI: 0xFFFFFFFF,
-      StartGroup_Unicode: 0xFFFFFFFF,
-      dwFlags: 0,
-      dwHotKey: 0,
-      dpBitmapOffset: 0,
-      dwBitmapSize: 0
-    };
-
-    let size = KMXFile.COMP_KEYBOARD_SIZE;
-
-    if(this.file instanceof KMXPlusFile) {
-      // Reserve space for KMXPlus header; we'll come back and fill in details
-      // once we know base kmx file size.
-      this.comp_header.dwFlags |= KMXFile.KF_KMXPLUS;
-      this.base_kmxplus = size;
-      size += KMXFile.COMP_KEYBOARD_KMXPLUSINFO_SIZE;
-    }
-
-    // Stores
-
-    this.comp_header.cxStoreArray = this.file.keyboard.stores.length;
-    this.comp_header.dpStoreArray = this.comp_header.cxStoreArray ? size : 0;
-    let storeBase = size;
-    size += this.file.keyboard.stores.length * KMXFile.COMP_STORE_SIZE;
-    for(let store of this.file.keyboard.stores) {
-      let comp_store: BUILDER_COMP_STORE = {
-        dwSystemID: store.dwSystemID,
-        dpName: 0,
-        dpString: 0
-      };
-      this.comp_stores.push({base: storeBase, store: store, obj: comp_store});
-      if(this.writeDebug /*TODO: || store.isOption*/) {
-        [comp_store.dpName, size] = this.calculateStringOffsetAndSize(store.dpName, size);
-      }
-
-      [comp_store.dpString, size] = this.calculateStringOffsetAndSize(store.dpString, size);
-      storeBase += KMXFile.COMP_STORE_SIZE;
-    }
-
-    // Groups
-
-    this.comp_header.cxGroupArray = this.file.keyboard.groups.length;
-    this.comp_header.dpGroupArray = this.comp_header.cxGroupArray ? size : 0;
-    let groupBase = size;
-    size += this.file.keyboard.groups.length * KMXFile.COMP_GROUP_SIZE;
-    for(let group of this.file.keyboard.groups) {
-      let comp_group: BUILDER_COMP_GROUP = {
-        dpName: 0,
-        dpKeyArray: 0,
-        dpMatch: 0,
-        dpNoMatch: 0,
-        cxKeyArray: group.keys.length,
-        fUsingKeys: group.fUsingKeys ? 1 : 0
-      };
-
-      let comp_keys: {base: number, key: KEY, obj: BUILDER_COMP_KEY}[] = [];
-
-      this.comp_groups.push({base: groupBase, group: group, obj: comp_group, keys: comp_keys});
-
-      if(this.writeDebug) {
-        [comp_group.dpName, size] = this.calculateStringOffsetAndSize(group.dpName, size);
-      }
-      [comp_group.dpMatch, size] = this.calculateStringOffsetAndSize(group.dpMatch, size);
-      [comp_group.dpNoMatch, size] = this.calculateStringOffsetAndSize(group.dpNoMatch, size);
-
-      // Keys within a group
-
-      comp_group.dpKeyArray = group.keys.length ? size : 0;
-
-      let keyBase = size;
-      size += group.keys.length * KMXFile.COMP_KEY_SIZE;
-      for(let key of group.keys) {
-        let comp_key: BUILDER_COMP_KEY = {
-          Key: key.Key,
-          _padding: 0,
-          Line: key.Line,
-          ShiftFlags: key.ShiftFlags,
-          dpOutput: 0,
-          dpContext: 0
-        };
-        comp_keys.push({base: keyBase, key: key, obj: comp_key});
-        [comp_key.dpOutput, size] = this.calculateStringOffsetAndSize(key.dpOutput, size, true);
-        [comp_key.dpContext, size] = this.calculateStringOffsetAndSize(key.dpContext, size, true);
-        keyBase += KMXFile.COMP_KEY_SIZE;
-      }
-
-      groupBase += KMXFile.COMP_GROUP_SIZE;
-    }
-
-    size += this.buildBitmap();
-    size += this.buildKMXPlus(size);
-
-    return size;
-  }
-
-  buildBitmap() {
-    // TODO
-    return 0;
-  }
-
-  buildKMXPlus(base: number) {
-    if(!(this.file instanceof KMXPlusFile)) {
-      return 0;
-    }
-
-    const plusbuilder: KMXPlusBuilder = new KMXPlusBuilder(this.file, this.writeDebug);
-    this.comp_kmxplus_data = plusbuilder.compile();
-    this.comp_kmxplus = {
-      dpKMXPlus: base,
-      dwKMXPlusSize: this.comp_kmxplus_data.length
-    };
-
-    return this.comp_kmxplus.dwKMXPlusSize;
-  }
-
-  setString(file: Uint8Array, pos: number, str: string, requireString: boolean = false): void {
-    if(requireString && !str.length) {
-      // Just write zero terminator, as r.String for a zero-length string
-      // seems to fail.
-      let sbuf = r.uint16le;
-      file.set(sbuf.toBuffer(0), pos);
-    }
-    else if(pos && str.length) {
-      let sbuf = new r.String(null, 'utf16le'); // null-terminated string
-      file.set(sbuf.toBuffer(str), pos);
-    }
-  }
-
-  compile(): Uint8Array {
-    const fileSize = this.build();
-
-    let file: Uint8Array = new Uint8Array(fileSize);
-
-    // Write headers
-
-    const header = this.file.COMP_KEYBOARD.toBuffer(this.comp_header);
-    file.set(header, this.base_keyboard);
-
-    if(this.file instanceof KMXPlusFile) {
-      const kmxplus: Uint8Array = this.file.COMP_KEYBOARD_KMXPLUSINFO.toBuffer(this.comp_kmxplus);
-      file.set(kmxplus, this.base_kmxplus);
-    }
-
-    // Write store array and data
-
-    for(let store of this.comp_stores) {
-      file.set(this.file.COMP_STORE.toBuffer(store.obj), store.base);
-      if(this.writeDebug) {
-        this.setString(file, store.obj.dpName, store.store.dpName);
-      }
-      this.setString(file, store.obj.dpString, store.store.dpString);
-    }
-
-    // Write group array and data
-
-    for(let group of this.comp_groups) {
-      file.set(this.file.COMP_GROUP.toBuffer(group.obj), group.base);
-      if(this.writeDebug) {
-        this.setString(file, group.obj.dpName, group.group.dpName);
-      }
-      this.setString(file, group.obj.dpMatch, group.group.dpMatch);
-      this.setString(file, group.obj.dpNoMatch, group.group.dpNoMatch);
-
-      for(let key of group.keys) {
-        file.set(this.file.COMP_KEY.toBuffer(key.obj), key.base);
-        // for back-compat reasons, these are never NULL strings
-        this.setString(file, key.obj.dpContext, key.key.dpContext, true);
-        this.setString(file, key.obj.dpOutput, key.key.dpOutput, true);
-      }
-    }
-
-    // Write KMXPlus data stream
-
-    if(this.file instanceof KMXPlusFile) {
-      file.set(this.comp_kmxplus_data, this.comp_kmxplus.dpKMXPlus);
-    }
-
-    return file;
-  }
-}

package/src/kmx/kmx-plus-builder/build-disp.ts

@@ -1,46 +0,0 @@
-import { constants } from '@keymanapp/ldml-keyboard-constants';
-import { KMXPlusData } from "../kmx-plus.js";
-import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
-import { BUILDER_SECTION } from './builder-section.js';
-
-/* ------------------------------------------------------------------
- * disp section
-   ------------------------------------------------------------------ */
-
-/**
- * Builder for the 'disp' section
- */
-interface BUILDER_DISP_ITEM {
-  to: number;
-  display: number;
-};
-
-export interface BUILDER_DISP extends BUILDER_SECTION {
-  count: number;
-  baseCharacter: number;
-  items: BUILDER_DISP_ITEM[];
-};
-
-export function build_disp(kmxplus: KMXPlusData, sect_strs: BUILDER_STRS): BUILDER_DISP {
-  if(!kmxplus.disp.disps.length && !kmxplus.disp.baseCharacter.value) {
-    return null;
-  }
-
-  let disp: BUILDER_DISP = {
-    ident: constants.hex_section_id(constants.section.disp),
-    size: constants.length_disp + constants.length_disp_item * kmxplus.disp.disps.length,
-    _offset: 0,
-    count: kmxplus.disp.disps.length,
-    baseCharacter: build_strs_index(sect_strs, kmxplus.disp.baseCharacter),
-    items: []
-  };
-
-  for(let item of kmxplus.disp.disps) {
-    disp.items.push({
-      to: build_strs_index(sect_strs, item.to),
-      display: build_strs_index(sect_strs, item.display),
-    });
-  }
-
-  return disp;
-}

package/src/kmx/kmx-plus-builder/build-elem.ts

@@ -1,103 +0,0 @@
-import { constants } from "@keymanapp/ldml-keyboard-constants";
-import { ElementString } from "../element-string.js";
-import { Elem } from "../kmx-plus.js";
-import { build_strs_index, BUILDER_STRS } from "./build-strs.js";
-import { BUILDER_SECTION } from "./builder-section.js";
-
-/* ------------------------------------------------------------------
- * elem section
-   ------------------------------------------------------------------ */
-
-interface BUILDER_ELEM_ELEMENT {
-  element: number;  // str | UTF-32 char
-  flags: number;
-  _value: string;
-};
-
-interface BUILDER_ELEM_STRING {
-  offset: number;
-  length: number;
-  items: BUILDER_ELEM_ELEMENT[];
-  _value: ElementString;
-};
-
-/**
- * Builder for the 'elem' section
- */
-export interface BUILDER_ELEM extends BUILDER_SECTION {
-  count: number;
-  strings: BUILDER_ELEM_STRING[];
-};
-
-function binaryElemCompare(a: BUILDER_ELEM_STRING, b: BUILDER_ELEM_STRING): number {
-  for(let i = 0; i < a.items.length && i < b.items.length; i++) {
-    if(a.items[i]._value < b.items[i]._value) return -1;
-    if(a.items[i]._value > b.items[i]._value) return 1;
-    if(a.items[i].flags < b.items[i].flags) return -1;
-    if(a.items[i].flags > b.items[i].flags) return 1;
-  }
-  if(a.items.length < b.items.length) return -1;
-  if(a.items.length > b.items.length) return 1;
-  return 0;
-}
-
-export function build_elem(source_elem: Elem, sect_strs: BUILDER_STRS): BUILDER_ELEM {
-  let result: BUILDER_ELEM = {
-    ident: constants.hex_section_id(constants.section.elem),
-    size: 0,  // finalized below
-    _offset: 0,
-    count: source_elem.strings.length,
-    strings: [], // finalized below
-  };
-
-  // TODO: consider padding
-  result.strings = source_elem.strings.map(item => {
-    let res: BUILDER_ELEM_STRING = {
-      offset: 0, // finalized below
-      length: item.length,
-      items: [],
-      _value: item
-    };
-
-    res.items = item.map(v => {
-      return {
-        element: build_strs_index(sect_strs, v.value),
-        flags: constants.elem_flags_unicode_set |
-              v.flags |                                                             //
-              ((v.order ?? 0) << constants.elem_flags_order_bitshift) |             // -128 to +127; used only by reorder element values
-              ((v.tertiary ?? 0) << constants.elem_flags_tertiary_bitshift),        // -128 to +127; used only by reorder element values
-        _value: v.value.value
-      };
-    });
-    return res;
-  });
-  result.strings.sort((a,b) => binaryElemCompare(a, b));
-
-  /* Calculate offsets and total size */
-
-  let offset = constants.length_elem + constants.length_elem_item * result.count;
-  for(let item of result.strings) {
-    if (item.length === 0) {
-      // no length gets a zero offset
-      item.offset = 0;
-    } else {
-      item.offset = offset;
-      offset += item.length * constants.length_elem_item_element;
-    }
-  }
-
-  result.size = offset;
-  return result;
-}
-
-export function build_elem_index(sect_elem: BUILDER_ELEM, value: ElementString) {
-  if(!(value instanceof ElementString)) {
-    throw new Error('unexpected value '+value);
-  }
-
-  const result = sect_elem.strings.findIndex(v => value.isEqual(v._value));
-  if(result < 0) {
-    throw new Error('unexpectedly missing StrsItem '+value);
-  }
-  return result;
-}