@keymanapp/common-types 17.0.85-alpha

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

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

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

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

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

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

@@ -0,0 +1,103 @@
+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;
+}