proskomma-core 0.9.10 → 0.9.13

package/src/transforms/perf2usfm.cjs

@@ -0,0 +1,294 @@
+const { PerfRenderFromJson } = require('proskomma-json-tools');
+
+const oneifyTag = t => {
+  if (['toc', 'toca', 'mt', 'imt', 's', 'ms', 'mte', 'sd'].includes(t)) {
+    return t + '1';
+  }
+  return t;
+};
+
+const buildMilestone = (atts, type) => {
+  let str=`\\${type}-s |`;
+
+  for (let [key, value] of Object.entries(atts)) {
+    if (key === 'x-morph') {
+      str = str + oneifyTag(key) + '="' + value.join(',') + '" ';
+    } else {
+      str = str + oneifyTag(key) + '="' + value + '" ';
+    }
+  };
+  return str + '\\*';
+};
+
+const buildEndWrapper = (atts, type, isnested = false) => {
+  let str='|';
+
+  for (let [key, value] of Object.entries(atts)) {
+    str = str + oneifyTag(key) + '="' + value + '" ';
+  };
+  str = str + '\\';
+
+  // if it's nested, we simply add a "+" sign before the type
+  if (isnested) {
+    str = str + '+';
+  }
+  return str + type + '*';
+};
+
+const localToUsfmActions = {
+  startDocument: [
+    {
+      description: 'Set up environment',
+      test: () => true,
+      action: ({ context, workspace }) => {
+        workspace.usfmBits = [''];
+        workspace.nestedWrapper = 0;
+
+        for (
+          let [key, value] of
+          Object.entries(context.document.metadata.document)
+            .filter(kv => !['tags', 'properties', 'bookCode', 'cl'].includes(kv[0]))
+        ) {
+          workspace.usfmBits.push(`\\${oneifyTag(key)} ${value}\n`);
+        };
+      },
+    },
+  ],
+  blockGraft: [
+    {
+      description: 'Follow block grafts',
+      test: ({ context }) => ['title', 'heading', 'introduction'].includes(context.sequences[0].block.subType),
+      action: (environment) => {
+        let contextSequence = environment.context.sequences[0];
+        let chapterValue = environment.config.report[contextSequence.block.blockN.toString()];
+        const target = contextSequence.block.target;
+
+        if (chapterValue && contextSequence.type === 'main') {
+          environment.workspace.usfmBits.push(`\n\\c ${chapterValue}\n`);
+        }
+
+        if (target) {
+          environment.context.renderer.renderSequenceId(environment, target);
+        }
+      },
+    },
+  ],
+  inlineGraft: [
+    {
+      description: 'Follow inline grafts',
+      test: () => true,
+      action: (environment) => {
+        const target = environment.context.sequences[0].element.target;
+
+        if (target) {
+          environment.context.renderer.renderSequenceId(environment, target);
+        }
+      },
+    },
+  ],
+  startParagraph: [
+    {
+      description: 'Output footnote paragraph tag (footnote)',
+      test: ({ context }) => (context.sequences[0].block.subType === 'usfm:f' && context.sequences[0].type === 'footnote')
+            || (context.sequences[0].block.subType === 'usfm:x' && context.sequences[0].type === 'xref'),
+      action: ({ context, workspace }) => {
+        workspace.nestedWrapper = 0;
+        let contextSequence = context.sequences[0];
+        workspace.usfmBits.push(`\\${oneifyTag(contextSequence.block.subType.split(':')[1])} `);
+      },
+    },
+    {
+      description: 'Output footnote note_caller tag (footnote)',
+      test: ({ context }) => context.sequences[0].block.subType === 'usfm:f' || context.sequences[0].block.subType === 'usfm:x',
+      action: ({ workspace }) => {
+        workspace.nestedWrapper = 0;
+      },
+    },
+    {
+      description: 'Output paragraph tag (main)',
+      test: () => true,
+      action: ({
+        context, workspace, config,
+      }) => {
+        workspace.nestedWrapper = 0;
+        let contextSequence = context.sequences[0];
+        let chapterValue = config.report[contextSequence.block.blockN.toString()];
+
+        if (chapterValue && contextSequence.type === 'main') {
+          workspace.usfmBits.push(`\n\\c ${chapterValue}\n`);
+        }
+        workspace.usfmBits.push(`\n\\${oneifyTag(contextSequence.block.subType.split(':')[1])}\n`);
+      },
+    },
+  ],
+  endParagraph: [
+    {
+      description: 'Output footnote paragraph tag (footnote)',
+      test: ({ context }) => (context.sequences[0].block.subType === 'usfm:f' && context.sequences[0].type === 'footnote')
+            || (context.sequences[0].block.subType === 'usfm:x' && context.sequences[0].type === 'xref'),
+      action: ({ context, workspace }) => {
+        let contextSequence = context.sequences[0];
+        workspace.usfmBits.push(`\\${oneifyTag(contextSequence.block.subType.split(':')[1])}*`);
+      },
+    },
+    {
+      description: 'Output footnote note_caller tag (footnote)',
+      test: ({ context }) => context.sequences[0].block.subType === 'usfm:f' || context.sequences[0].block.subType === 'usfm:x',
+      action: () => {
+      },
+    },
+    {
+      description: 'Output nl',
+      test: () => true,
+      action: ({ workspace }) => {
+        workspace.usfmBits.push(`\n`);
+      },
+    },
+  ],
+  startMilestone: [
+    {
+      description: 'Output start milestone',
+      test: () => true,
+      action: ({ context, workspace }) => {
+        let contextSequenceElement = context.sequences[0].element;
+        let newStartMileStone = buildMilestone(contextSequenceElement.atts, oneifyTag(contextSequenceElement.subType.split(':')[1]));
+        workspace.usfmBits.push(newStartMileStone);
+      },
+    },
+  ],
+  endMilestone: [
+    {
+      description: 'Output end milestone',
+      test: () => true,
+      action: ({ context, workspace }) => {
+        workspace.usfmBits.push(`\\${oneifyTag(context.sequences[0].element.subType.split(':')[1])}-e\\*`);
+      },
+    },
+  ],
+  text: [
+    {
+      description: 'Output text',
+      test: () => true,
+      action: ({ context, workspace }) => {
+        const text = context.sequences[0].element.text;
+        workspace.usfmBits.push(text);
+      },
+    },
+  ],
+  mark: [
+    {
+      description: 'Output chapter or verses',
+      test: () => true,
+      action: ({ context, workspace }) => {
+        const element = context.sequences[0].element;
+
+        if (element.subType === 'verses') {
+          workspace.usfmBits.push(`\n\\v ${element.atts['number']}\n`);
+        }
+      },
+    },
+  ],
+  endSequence: [
+    {
+      description: 'Output \\cl',
+      test: ({ context }) => context.document.metadata.document.cl && context.sequences[0].type === 'title',
+      action: ({ context, workspace }) => {
+        workspace.usfmBits.push(`\n\\cl ${context.document.metadata.document.cl}\n`);
+      },
+    },
+  ],
+  startWrapper: [
+    {
+      description: 'Output start tag',
+      test: () => true,
+      action: ({ workspace, context }) => {
+        let contextSequence = context.sequences[0];
+
+        // handle nested wrappers : https://ubsicap.github.io/usfm/characters/nesting.html
+        if (workspace.nestedWrapper > 0) {
+          workspace.usfmBits.push(`\\+${oneifyTag(contextSequence.element.subType.split(':')[1])} `);
+        } else {
+          workspace.usfmBits.push(`\\${oneifyTag(contextSequence.element.subType.split(':')[1])} `);
+        }
+        workspace.nestedWrapper += 1;
+      },
+    },
+  ],
+  endWrapper: [
+    {
+      description: 'Output end tag',
+      test: ({ context }) => !['fr', 'fq','fqa','fk','fl','fw','fp', 'ft', 'xo', 'xk', 'xq', 'xt', 'xta']
+        .includes(context.sequences[0].element.subType.split(':')[1]),
+      action: ({ workspace, context }) => {
+        workspace.nestedWrapper -= 1;
+        let contextSequence = context.sequences[0];
+        let subType = contextSequence.element.subType.split(':')[1];
+        let isNested = workspace.nestedWrapper > 0;
+
+        if (subType === 'w') {
+          let newEndW = buildEndWrapper(contextSequence.element.atts, oneifyTag(subType), isNested);
+          workspace.usfmBits.push(newEndW);
+        } else {
+          // handle nested wrappers : https://ubsicap.github.io/usfm/characters/nesting.html
+          if (isNested) {
+            workspace.usfmBits.push(`\\+${oneifyTag(contextSequence.element.subType.split(':')[1])}*`);
+          } else {
+            workspace.usfmBits.push(`\\${oneifyTag(contextSequence.element.subType.split(':')[1])}*`);
+          }
+        }
+      },
+    },
+    {
+      description: 'Do NOT output end tag',
+      test: () => true,
+      action: ({ workspace }) => {
+        workspace.nestedWrapper -= 1;
+      },
+    },
+  ],
+  endDocument: [
+    {
+      description: 'Build output',
+      test: () => true,
+      action: ({ workspace, output }) => {
+        output.usfm = workspace.usfmBits.join('').replace(/(\s*)\n(\s*)/gm, '\n');
+      },
+    },
+  ],
+};
+
+const perf2usfmCode = function ({ perf, report }) {
+  const cl = new PerfRenderFromJson({ srcJson: perf, actions: localToUsfmActions });
+  const output = {};
+
+  cl.renderDocument({
+    docId: '', config: { report }, output,
+  });
+  return { usfm: output.usfm };
+};
+
+const perf2usfm = {
+  name: 'perf2usfm',
+  type: 'Transform',
+  description: 'PERF=>USFM',
+  inputs: [
+    {
+      name: 'perf',
+      type: 'json',
+      source: '',
+    },
+    {
+      name: 'report',
+      type: 'json',
+      source: '',
+    },
+  ],
+  outputs: [
+    {
+      name: 'usfm',
+      type: 'text',
+    },
+  ],
+  code: perf2usfmCode,
+};
+module.exports = perf2usfm;

package/src/util/byteArray.cjs

@@ -0,0 +1,251 @@
+const { utf8ByteArrayToString, stringToUtf8ByteArray } = require('utf8-string-bytes');
+const base64 = require('base64-js');
+
+const checkNum = (n, func, field) => {
+  if (typeof n !== 'number') {
+    throw new Error(`Argument ${field} of ${func} should be a number, not '${n}' (${typeof n})`);
+  }
+};
+
+class ByteArray {
+  constructor(initialArraySize, initialLength) {
+    initialArraySize = initialArraySize || 64;
+    initialLength = initialLength || 0;
+    this.growMax = 1024 * 16;
+    this.length = initialLength;
+    this.byteArray = new Uint8Array(initialArraySize);
+  }
+
+  byte(n) {
+    checkNum(n, 'byte', 'n');
+
+    if (n > this.length - 1) {
+      throw Error(`Attempt to read byte ${n} of ByteArray of length ${this.length}`);
+    }
+    return this.byteArray[n];
+  }
+
+  bytes(n, l) {
+    checkNum(n, 'bytes', 'n');
+    checkNum(l, 'bytes', 'l');
+
+    if ((n + l) > this.length) {
+      throw Error(`Attempt to read ${l} bytes from start ${n} of ByteArray of length ${this.length}`);
+    }
+    return this.byteArray.subarray(n, n + l);
+  }
+
+  setByte(n, v) {
+    checkNum(n, 'setByte', 'n');
+    checkNum(v, 'setByte', 'v');
+
+    if (n > this.length - 1) {
+      throw Error(`Attempt to set byte ${n} of ByteArray of length ${this.length}`);
+    }
+
+    if (typeof (v) !== 'number' || v < 0 || v > 255) {
+      throw Error(`Expected value 0-255 when setting ByteArray, found ${v}`);
+    }
+    this.byteArray[n] = v;
+  }
+
+  setBytes(n, v) {
+    checkNum(n, 'setBytes', 'n');
+
+    if ((n + v.length) > this.length) {
+      throw Error(`Attempt to set ${v.length} bytes from start ${n} of ByteArray of length ${this.length}`);
+    }
+    this.byteArray.set(v, n);
+  }
+
+  pushByte(v) {
+    if (typeof (v) !== 'number' || v < 0 || v > 255) {
+      throw Error(`Expected value 0-255 when pushing to ByteArray, found ${v}`);
+    }
+
+    if (this.length === this.byteArray.length) {
+      this.grow();
+    }
+    this.byteArray[this.length] = v;
+    this.length++;
+  }
+
+  grow(minNewSize) {
+    const newBytes = new Uint8Array(
+      Math.max(
+        minNewSize || 0,
+        this.byteArray.length + (
+          Math.min(
+            this.growMax,
+            Math.max(
+              16,
+              this.byteArray.length,
+            ),
+          )
+        ),
+      ),
+    );
+    newBytes.set(this.byteArray);
+    this.byteArray = newBytes;
+  }
+
+  trim() {
+    const newBytes = new Uint8Array(this.length);
+    newBytes.set(this.byteArray.subarray(0, this.length));
+    this.byteArray = newBytes;
+  }
+
+  pushBytes(v) {
+    for (const ve of v) {
+      this.pushByte(ve);
+    }
+  }
+
+  pushNByte(v) {
+    checkNum(v, 'pushNByte', 'v');
+
+    // Low byte(s) first
+    if (typeof (v) !== 'number' || v < 0) {
+      throw Error(`Expected positive number in pushNByte, found ${v}`);
+    }
+
+    if (v < 128) {
+      this.pushByte(v + 128);
+    } else {
+      const modulo = v % 128;
+      this.pushByte(modulo);
+      this.pushNByte(v >> 7);
+    }
+  }
+
+  pushNBytes(vArray) {
+    for (const v of vArray) {
+      try {
+        this.pushNByte(v);
+      } catch (err) {
+        throw Error(`Error from pushNByte, called as pushNBytes(${JSON.stringify(vArray)})`);
+      }
+    }
+  }
+
+  nByte(n) {
+    checkNum(n, 'nByte', 'n');
+
+    if (n > this.length - 1) {
+      throw Error(`Attempt to read nByte ${n} of ByteArray of length ${this.length}`);
+    }
+
+    const v = this.byteArray[n];
+
+    if (v > 127) {
+      return v - 128;
+    } else {
+      return v + (128 * this.nByte(n + 1));
+    }
+  }
+
+  nBytes(n, nValues) {
+    checkNum(n, 'nBytes', 'n');
+    checkNum(nValues, 'nBytes', 'nValues');
+    const ret = [];
+
+    while (nValues > 0) {
+      let done = false;
+      let currentValue = 0;
+      let multiplier = 1;
+
+      do {
+        if (n > this.length - 1) {
+          throw Error(`Attempt to read nByte ${n} of ByteArray of length ${this.length} in nBytes(${n}, ${nValues})`);
+        }
+
+        const v = this.byteArray[n];
+
+        if (v > 127) {
+          currentValue += ((v - 128) * multiplier);
+          ret.push(currentValue);
+          currentValue = 0;
+          done = true;
+        } else {
+          currentValue += (v * multiplier);
+          multiplier *= 128;
+        }
+        n++;
+      } while (!done);
+      nValues--;
+    }
+    return ret;
+  }
+
+  nByteLength(v) {
+    checkNum(v, 'nByteLength', 'v');
+
+    if (v >= 128 ** 4) {
+      throw new Error('> 4 bytes found in nByteLength');
+    }
+
+    let ret = 1;
+
+    while (v > 127) {
+      v = v >> 7;
+      ret += 1;
+    }
+    return ret;
+  }
+
+  pushCountedString(s) {
+    const sA = stringToUtf8ByteArray(s);
+    this.pushByte(sA.length);
+    this.pushBytes(sA);
+  }
+
+  countedString(n) {
+    checkNum(n, 'countedString', 'n');
+    const sLength = this.byte(n);
+    return utf8ByteArrayToString(this.bytes(n + 1, sLength));
+  }
+
+  clear() {
+    this.byteArray.fill(0);
+    this.length = 0;
+  }
+
+  base64() {
+    return base64.fromByteArray(this.byteArray);
+  }
+
+  fromBase64(s) {
+    this.byteArray = base64.toByteArray(s);
+    this.length = this.byteArray.length;
+  }
+
+  deleteItem(n) {
+    checkNum(n, 'deleteItem', 'n');
+    const itemLength = this.byte(n) & 0x0000003F;
+    this.length -= itemLength;
+
+    if (this.length > n) {
+      const remainingBytes = this.byteArray.slice(n + itemLength);
+      this.byteArray.set(remainingBytes, n);
+    }
+  }
+
+  insert(n, iba) {
+    checkNum(n, 'insert', 'n');
+    const insertLength = iba.length;
+    const newLength = this.length + insertLength;
+
+    if (newLength >= (this.byteArray.length + insertLength)) {
+      this.grow(newLength);
+    }
+
+    if (n < newLength) {
+      const displacedBytes = this.byteArray.slice(n, this.length);
+      this.byteArray.set(displacedBytes, n + insertLength);
+    }
+    this.byteArray.set(iba.byteArray.slice(0, iba.length), n);
+    this.length = newLength;
+  }
+}
+
+module.exports = ByteArray;

package/src/util/canons.cjs

@@ -0,0 +1,117 @@
+const ptBookArray = [
+  { code: 'GEN', categories:['ot', 'pentateuch'] },
+  { code: 'EXO', categories:['ot', 'pentateuch'] },
+  { code: 'LEV', categories:['ot', 'pentateuch'] },
+  { code: 'NUM', categories:['ot', 'pentateuch'] },
+  { code: 'DEU', categories:['ot', 'pentateuch'] },
+  { code: 'JOS', categories:['ot', 'history'] },
+  { code: 'JDG', categories:['ot', 'history'] },
+  { code: 'RUT', categories:['ot', 'history'] },
+  { code: '1SA', categories:['ot', 'history'] },
+  { code: '2SA', categories:['ot', 'history'] },
+  { code: '1KI', categories:['ot', 'history'] },
+  { code: '2KI', categories:['ot', 'history'] },
+  { code: '1CH', categories:['ot', 'history'] },
+  { code: '2CH', categories:['ot', 'history'] },
+  { code: 'EZR', categories:['ot', 'history'] },
+  { code: 'NEH', categories:['ot', 'history'] },
+  { code: 'EST', categories:['ot', 'history'] },
+  { code: 'JOB', categories:['ot', 'wisdom'] },
+  { code: 'PSA', categories:['ot', 'wisdom'] },
+  { code: 'PRO', categories:['ot', 'wisdom'] },
+  { code: 'ECC', categories:['ot', 'wisdom'] },
+  { code: 'SNG', categories:['ot', 'wisdom'] },
+  { code: 'ISA', categories:['ot', 'prophecy'] },
+  { code: 'JER', categories:['ot', 'prophecy'] },
+  { code: 'LAM', categories:['ot', 'prophecy'] },
+  { code: 'EZK', categories:['ot', 'prophecy'] },
+  { code: 'DAN', categories:['ot', 'prophecy'] },
+  { code: 'HOS', categories:['ot', 'prophecy'] },
+  { code: 'JOL', categories:['ot', 'prophecy'] },
+  { code: 'AMO', categories:['ot', 'prophecy'] },
+  { code: 'OBA', categories:['ot', 'prophecy'] },
+  { code: 'JON', categories:['ot', 'prophecy'] },
+  { code: 'MIC', categories:['ot', 'prophecy'] },
+  { code: 'NAM', categories:['ot', 'prophecy'] },
+  { code: 'HAB', categories:['ot', 'prophecy'] },
+  { code: 'ZEP', categories:['ot', 'prophecy'] },
+  { code: 'HAG', categories:['ot', 'prophecy'] },
+  { code: 'ZEC', categories:['ot', 'prophecy'] },
+  { code: 'MAL', categories:['ot', 'prophecy'] },
+  { code: 'MAT', categories:['nt', 'gospel', 'synoptic'] },
+  { code: 'MRK', categories:['nt', 'gospel', 'synoptic'] },
+  { code: 'LUK', categories:['nt', 'gospel', 'synoptic'] },
+  { code: 'JHN', categories:['nt', 'gospel'] },
+  { code: 'ACT', categories:['nt', 'gospel'] },
+  { code: 'ROM', categories:['nt', 'epistle'] },
+  { code: '1CO', categories:['nt', 'epistle'] },
+  { code: '2CO', categories:['nt', 'epistle'] },
+  { code: 'GAL', categories:['nt', 'epistle'] },
+  { code: 'EPH', categories:['nt', 'epistle'] },
+  { code: 'PHP', categories:['nt', 'epistle'] },
+  { code: 'COL', categories:['nt', 'epistle'] },
+  { code: '1TH', categories:['nt', 'epistle'] },
+  { code: '2TH', categories:['nt', 'epistle'] },
+  { code: '1TI', categories:['nt', 'epistle'] },
+  { code: '2TI', categories:['nt', 'epistle'] },
+  { code: 'TIT', categories:['nt', 'epistle'] },
+  { code: 'PHM', categories:['nt', 'epistle'] },
+  { code: 'HEB', categories:['nt', 'epistle'] },
+  { code: 'JAS', categories:['nt', 'epistle'] },
+  { code: '1PE', categories:['nt', 'epistle'] },
+  { code: '2PE', categories:['nt', 'epistle'] },
+  { code: '1JN', categories:['nt', 'epistle'] },
+  { code: '2JN', categories:['nt', 'epistle'] },
+  { code: '3JN', categories:['nt', 'epistle'] },
+  { code: 'JUD', categories:['nt', 'epistle'] },
+  { code: 'REV', categories:['nt', 'epistle'] },
+  { code: 'TOB', categories:['dc'] },
+  { code: 'JDT', categories:['dc'] },
+  { code: 'ESG', categories:['dc', 'history'] },
+  { code: 'WIS', categories:['dc', 'wisdom'] },
+  { code: 'SIR', categories:['dc', 'wisdom'] },
+  { code: 'BAR', categories:['dc', 'prophecy'] },
+  { code: 'LJE', categories:['dc'] },
+  { code: 'S3Y', categories:['dc'] },
+  { code: 'SUS', categories:['dc'] },
+  { code: 'BEL', categories:['dc'] },
+  { code: '1MA', categories:['dc'] },
+  { code: '2MA', categories:['dc'] },
+  { code: '3MA', categories:['dc'] },
+  { code: '4MA', categories:['dc'] },
+  { code: '1ES', categories:['dc'] },
+  { code: '2ES', categories:['dc'] },
+  { code: 'MAN', categories:['dc'] },
+  { code: 'PS2', categories:['dc'] },
+  { code: 'ODA', categories:['dc'] },
+  { code: 'PSS', categories:['dc'] },
+  { code: 'JSA', categories:['dc'] },
+  { code: 'JDB', categories:['dc'] },
+  { code: 'TBS', categories:['dc'] },
+  { code: 'SST', categories:['dc'] },
+  { code: 'DNT', categories:['dc'] },
+  { code: 'BLT', categories:['dc'] },
+  { code: 'EZA', categories:['dc'] },
+  { code: '5EZ', categories:['dc'] },
+  { code: '6EZ', categories:['dc'] },
+  { code: 'DAG', categories:['dc'] },
+  { code: 'PS3', categories:['dc'] },
+  { code: '2BA', categories:['dc'] },
+  { code: 'LBA', categories:['dc'] },
+  { code: 'JUB', categories:['dc'] },
+  { code: 'ENO', categories:['dc'] },
+  { code: '1MQ', categories:['dc'] },
+  { code: '2MQ', categories:['dc'] },
+  { code: '3MQ', categories:['dc'] },
+  { code: 'REP', categories:['dc'] },
+  { code: '4BA', categories:['dc'] },
+  { code: 'LAO', categories:['dc'] },
+];
+
+let ptBooks = {};
+
+for (const br of ptBookArray.entries()) {
+  ptBooks[br[1].code] = { ...br[1], position: br[0] };
+}
+
+module.exports = { ptBookArray, ptBooks };

package/src/util/enums.cjs

@@ -0,0 +1,41 @@
+const xre = require('xregexp');
+
+const enumStringIndex = (enumSuccinct, str) => {
+  let pos = 0;
+  let count = 0;
+
+  while (pos < enumSuccinct.length) {
+    const stringLength = enumSuccinct.byte(pos);
+    const enumString = enumSuccinct.countedString(pos);
+
+    if (enumString === str) {
+      return count;
+    }
+    pos += (stringLength + 1);
+    count += 1;
+  }
+  return -1;
+};
+
+const enumRegexIndexTuples = (enumSuccinct, regex) => {
+  let pos = 0;
+  let count = 0;
+  const ret = [];
+
+  while (pos < enumSuccinct.length) {
+    const stringLength = enumSuccinct.byte(pos);
+    const enumString = enumSuccinct.countedString(pos);
+
+    if (xre.exec(enumString, xre(regex, 'i'))) {
+      ret.push([count, enumString]);
+    }
+    pos += (stringLength + 1);
+    count += 1;
+  }
+  return ret;
+};
+
+module.exports = {
+  enumStringIndex,
+  enumRegexIndexTuples,
+};