@temperlang/core 0.0.3

package/index.js

@@ -0,0 +1,794 @@
+export * from './interface-types.js';
+export * from './regex.js';
+
+export const noResultException = new (
+  class NoResultException extends Error {
+    constructor() {
+      super("NoResult");
+    }
+  }
+);
+
+// Implements extension method String::isEmpty
+export function stringIsEmpty(s) { return s === ''; }
+// Implements extension method String::split
+export function stringSplit(s, separator) {
+  return s.split(separator).map((s) => s);
+}
+
+/** Specifically for utf8 and utf32, since utf16 is simpler in js. */
+class TrickyStringSlice {
+  #length;
+
+  hasAtLeast(count) {
+    // Repeated calls to hasAtLeast are potentially expensive.
+    return (this.#length ?? this._lengthUntil(count)) >= count;
+  }
+
+  get length() {
+    if (this.#length === undefined) {
+      this.#length = this._lengthUntil();
+    }
+    return this.#length;
+  }
+
+  _lengthUntil(stop = undefined) {
+    // To be overridden in subclasses.
+    return 0;
+  }
+}
+
+class Utf8StringSlice extends TrickyStringSlice {
+  /** The underlying string value. */
+  #content;
+  /**
+   * The byte index approximation of the left side.
+   * A byte index approximation is an integer, i, such that:
+   * - (i >> 2) is the index of a codepoint in #content
+   * - (i & 3)  is the index of a byte within the UTF-8 representation of that codepoint.
+   */
+  #left;
+  /** The byte index approximation of the right side. */
+  #right;
+
+  constructor(content, left = 0, right = content.length * 4) {
+    super();
+    this.#content = content;
+    this.#left = left;
+    this.#right = right;
+  }
+
+  toString() {
+    let left = this.#left;
+    let right = this.#right;
+    let content = this.#content;
+
+    if (left === right) { return ""; }
+
+    // If we're only using some bytes on the left or right, replace that codepoint with U+FFFD.
+    let leftPartial = left & 3; // Do we have an incomplete code-point on the left?
+    let leftIndex = (left + 3) >> 2;
+    let rightIndex = right >> 2;
+    let rightPartial = (right & 3);
+
+    // If leftIndex is in the middle of a surrogate pair, advance over the tail.
+    if (leftIndex < rightIndex) {
+      let leftCodeUnitUtf16 = content.charCodeAt(leftIndex);
+      if (0xDC00 < leftCodeUnitUtf16 && leftCodeUnitUtf16 <= 0xDFFF) {
+        leftIndex += 1;
+      }
+    }
+
+    if (leftIndex > rightIndex) { return "\uFFFD"; }
+
+    let sub = content.substring(leftIndex, rightIndex);
+    if (leftPartial || rightPartial) {
+      return `${leftPartial ? "\uFFFD" : ""}${sub}${rightPartial ? "\uFFFD" : ""}`
+    } else {
+      return sub;
+    }
+  }
+
+  valueOf() { return this.toString(); }
+
+  _lengthUntil(stop) {
+    const left = this.#left;
+    const right = this.#right;
+    const content = this.#content;
+    let i = left >> 2;
+    // Add bytes between codePointBoundaryBeforeLimit and right
+    // Subtract bytes past zeroth in codepoint for left
+    let len = (right & 3) - (left & 3);
+    const codePointBoundaryBeforeLimit = (right & ~3) >> 2;
+    while (i < codePointBoundaryBeforeLimit) {
+      if (stop !== undefined && len >= stop) {
+        break;
+      }
+      let cp = content.codePointAt(i);
+      let nBytes = nUtf8BytesInChar(cp);
+      len += nBytes;
+      i += (4 + nBytes) >> 2;
+    }
+    return len;
+  }
+
+  get isEmpty() {
+    return this.#left >= this.#right;
+  }
+
+  read() {
+    let left = this.#left;
+    let right = this.#right;
+    if (left >= right) {
+      throw noResultException;
+    }
+
+    let content = this.#content;
+    let cp = content.codePointAt(left >> 2);
+    if (cp < 0x80) {
+      return cp;
+    } else {
+      let byteOffset = left & 3;
+      let nBytes = nUtf8BytesInChar(cp);
+      let byteInfo = byteInfos[(nBytes - 1) * 4 + byteOffset];
+      let codeUnit = ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
+      return codeUnit;
+    }
+  }
+
+  advance(count) {
+    if (count <= 0) {
+      return this;
+    } else if (count === 1) {
+      let left = this.#left;
+      let right = this.#right;
+      if (left >= right) {
+        return this;
+      }
+      let content = this.#content;
+      let cp = content.codePointAt(left >> 2);
+      let newLeft;
+      if (cp < 0x80) {
+        newLeft = left + 4;
+      } else {
+        let byteOffset = left & 3;
+        let nBytes = nUtf8BytesInChar(cp);
+        newLeft = (byteOffset + 1 < nBytes) ? left + 1 : (left & ~3) + ((nBytes + 4) & ~3);
+      }
+      return new Utf8StringSlice(content, newLeft, right);
+    } else {
+      throw new Error("TODO");
+    }
+  }
+
+  [Symbol.iterator]() {
+    function *bytes(content, left, limit) {
+      let i = left;
+      while (i < limit) {
+        let cp = content.codePointAt(i >> 2);
+        if (cp < 0x80) {
+          yield cp;
+          i += 4;
+        } else {
+          let byteOffset = i & 3;
+          let nBytes = nUtf8BytesInChar(cp);
+          let byteInfo = byteInfos[(nBytes - 1) * 4 + byteOffset];
+          let codeUnit = ((cp >>> byteInfo.shift) & byteInfo.andMask) | byteInfo.orMask;
+          yield codeUnit;
+          i = (byteOffset + 1 < nBytes) ? i + 1 : (i & ~3) + ((nBytes + 4) & ~3);
+        }
+      }
+    }
+    return bytes(this.#content, this.#left, this.#right);
+  }
+
+  toJSON() {
+    return { content: this.#content, left: this.#left, right: this.#right };
+  }
+}
+
+class Utf16StringSlice {
+  /** The underlying string value. */
+  #content;
+  /**
+   * A regular character offset of the left of the slice, inclusive.
+   */
+  #left;
+  /** A regular character offset of the right of the slice, exclusive. */
+  #right;
+
+  constructor(content, left = 0, right = content.length) {
+    this.#content = content;
+    this.#left = left;
+    this.#right = right;
+  }
+
+  toString() {
+    return this.#content.substring(this.#left, this.#right);
+  }
+
+  valueOf() { return this.toString(); }
+
+  hasAtLeast(count) {
+    return this.length >= count;
+  }
+
+  get length() {
+    return this.#right - this.#left;
+  }
+
+  get isEmpty() {
+    return this.#left >= this.#right;
+  }
+
+  read() {
+    let left = this.#left;
+    let right = this.#right;
+    if (left >= right) { throw noResultException; }
+    return this.#content.charCodeAt(left);
+  }
+
+  advance(count) {
+    if (count <= 0) {
+      return this;
+    } else {
+      let left = this.#left;
+      let right = this.#right;
+      if (left >= right) {
+        return this;
+      }
+      let newLeft = left + count;
+      if (newLeft >= right) { newLeft = right; }
+      return new Utf16StringSlice(this.#content, newLeft, right);
+    }
+  }
+
+  [Symbol.iterator]() {
+    function *chars(content, left, limit) {
+      let i = left;
+      while (i < limit) {
+        yield content.charCodeAt(i)
+        i += 1
+      }
+    }
+    return chars(this.#content, this.#left, this.#right);
+  }
+
+  toJSON() {
+    return { content: this.#content, left: this.#left, right: this.#right };
+  }
+}
+
+class CodePointsStringSlice extends TrickyStringSlice {
+  /** The underlying string value. */
+  #content;
+  /**
+   * A regular character offset of the left of the slice, inclusive.
+   */
+  #left;
+  /** A regular character offset of the right of the slice, exclusive. */
+  #right;
+
+  constructor(content, left = 0, right = content.length) {
+    super();
+    this.#content = content;
+    this.#left = left;
+    this.#right = right;
+  }
+
+  toString() {
+    return this.#content.substring(this.#left, this.#right);
+  }
+
+  valueOf() { return this.toString(); }
+
+  _lengthUntil(stop) {
+    const left = this.#left;
+    const right = this.#right;
+    const content = this.#content;
+    let i = left;
+    let len = 0;
+    while (i < right) {
+      if (stop !== undefined && len >= stop) {
+        break;
+      }
+      let cp = content.codePointAt(i);
+      if (cp > 0xFFFF) {
+        i += 2;
+      } else {
+        i += 1;
+      }
+      len += 1;
+    }
+    return len;
+  }
+
+  get isEmpty() {
+    return this.#left >= this.#right;
+  }
+
+  read() {
+    let left = this.#left;
+    let right = this.#right;
+    if (left >= right) { throw noResultException; }
+    return this.#content.codePointAt(left);
+  }
+
+  advance(count) {
+    if (count <= 0) {
+      return this;
+    } else {
+      let left = this.#left;
+      let right = this.#right;
+      let content = this.#content;
+      if (left >= right) {
+        return this;
+      }
+      let newLeft = left;
+      for (let i = count; i && newLeft < right; --i) {
+        let cp = content.codePointAt(newLeft);
+        if (cp > 0xFFFF) {
+          newLeft += 2;
+        } else {
+          newLeft += 1;
+        }
+      }
+      if (newLeft >= right) { newLeft = right; }
+      return new CodePointsStringSlice(this.#content, newLeft, right);
+    }
+  }
+
+  [Symbol.iterator]() {
+    function *chars(content, left, limit) {
+      let i = left;
+      while (i < limit) {
+        let cp = content.codePointAt(i);
+        yield cp;
+        i += (cp > 0xFFFF) ? 2 : 1;
+      }
+    }
+    return chars(this.#content, this.#left, this.#right);
+  }
+
+  toJSON() {
+    return { content: this.#content, left: this.#left, right: this.#right };
+  }
+}
+
+
+// Implements extension method String::utf8
+export function stringUtf8(string) {
+  return new Utf8StringSlice(string);
+}
+
+// Implements extension method String::utf16
+export function stringUtf16(string) {
+  return new Utf16StringSlice(string);
+}
+
+// Implements extension method String::codePoints
+export function stringCodePoints(string) {
+  return new CodePointsStringSlice(string);
+}
+
+// Implements extension method Int::toString
+export function intToString(i, radix) {
+  return i.toString(radix);
+}
+
+// Implements extension method Float64::toString
+export function float64ToString(n) {
+  // TODO(mikesamuel, issue#579): need functional test to nail down
+  // double formatting threshholds.
+  switch (n) {
+    case 0:
+      // differentiating negative zero from zero is a pain. Got this solution from
+      // https://dev.to/emnudge/identifying-negative-zero-2j1o
+      if (1 / n == Infinity) {
+        return "0.0"
+      }
+      else {
+        return "-0.0"
+      }
+    case Infinity:
+      return "∞"
+    case Number.NEGATIVE_INFINITY:
+      return "-∞"
+    default:
+      return n.toString();
+  };
+}
+
+function nUtf8BytesInChar(cp) {
+  return (cp < 0x0800)
+    ? ((cp < 0x80) ? 1 : 2)
+    : ((cp < 0x10000) ? 3 : 4)
+}
+
+/*
+ * | First code point | Last code point | Byte 0    | Byte 1    | Byte 2    | Byte 3    |
+ * | ---------------- | --------------- | --------- | --------- | --------- | --------- |
+ * | U+0000           | U+007F          | 0xxx_xxxx |           |           |           |
+ * | U+0080           | U+07FF          | 110x_xxxx | 10xx_xxxx |           |           |
+ * | U+0800           | U+FFFF          | 1110_xxxx | 10xx_xxxx | 10xx_xxxx |           |
+ * | U+10000          | U+10FFFF        | 1111_0xxx | 10xx_xxxx | 10xx_xxxx | 10xx_xxxx |
+ */
+const byteInfos = [
+  { andMask: 0b0111_1111, orMask: 0, shift: 0 },
+  null,
+  null,
+  null,
+
+  { andMask: 0b0001_1111, orMask: 0b1100_0000, shift: 6 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 0 },
+  null,
+  null,
+
+  { andMask: 0b0000_1111, orMask: 0b1110_0000, shift: 12 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 6 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 0 },
+  null,
+
+  { andMask: 0b0000_0111, orMask: 0b1111_0000, shift: 18 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 12 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 6 },
+  { andMask: 0b0011_1111, orMask: 0b1000_0000, shift: 0 },
+];
+
+function freeze(items) {
+  return Object.freeze(items);
+}
+
+// Implements extension method ListBuilder::add
+export function listBuilderAdd(ls, newItem, at) {
+  if (at === undefined) {
+    // Technically, we could also use splice instead of push for this case.
+    // Which is better might depend on minifiers and/or execution speed.
+    ls.push(newItem);
+  } else {
+    if (at < 0 || at > ls.length) {
+      throw noResultException;
+    }
+    ls.splice(at, 0, newItem);
+  }
+  return; // of type tVoid
+}
+
+// Implements extension method ListBuilder::addAll
+export function listBuilderAddAll(ls, newItems, at) {
+  if (at === undefined) {
+    ls.push(...newItems);
+  } else {
+    if (at < 0 || at > ls.length) {
+      throw noResultException;
+    }
+    ls.splice(at, 0, ...newItems);
+  }
+  return; // of type tVoid
+}
+// Implements extension method List::filter
+export function listFilter(ls, predicate) {
+  let filtered = null;
+  let nFiltered = 0; // Just past index of last element of ls filtered onto filtered
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    let element = ls[i];
+    let ok = predicate(element);
+    if (!ok) {
+      if (!filtered) {
+        filtered = [];
+      }
+      filtered.push(...ls.slice(nFiltered, i));
+      nFiltered = i + 1;
+    }
+  }
+  let fullyFiltered;
+  if (filtered) {
+    filtered.push(...ls.slice(nFiltered, length));
+    fullyFiltered = filtered;
+  } else {
+    fullyFiltered = ls;
+  }
+  return freeze(fullyFiltered);
+}
+// Implements extension method List::get
+export function listGet(ls, i) {
+  let { length } = ls;
+  if (0 <= i && i < length) { return ls[i]; }
+  throw noResultException;
+}
+// Implements extension method List::getOr
+export function listGetOr(ls, i, fallback) {
+  let { length } = ls;
+  return (0 <= i && i < length) ? ls[i] : fallback;
+}
+// Implements extension method List::isEmpty
+export function listIsEmpty(ls) {
+  return !ls.length;
+}
+// Implements extension method List::join
+export function listJoin(ls, separator, elementStringifier) {
+  let joined = '';
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    if (i) {
+      joined += separator;
+    }
+    let element = ls[i];
+    let stringifiedElement = elementStringifier(element);
+    joined += stringifiedElement;
+  }
+  return joined;
+}
+// Implements extension method List::length
+export function listLength(ls) { return ls.length; }
+// Implements extension method List::mapDropping
+export function listMapDropping() { throw new Error("TODO List::mapDropping"); }
+// Implements extension method List::map
+export function listMap(ls, transform) {
+  let mapped = [];
+  let { length } = ls;
+  for (let i = 0; i < length; ++i) {
+    let transformed = transform(ls[i]);
+    mapped[i] = transformed;
+  }
+  return freeze(mapped);
+}
+// Implements extension method ListBuilder::reverse
+export function listBuilderReverse(ls) {
+  let { length } = ls;
+  let lastIndex = length - 1;
+  let mid = length >> 1;
+  for (let i = 0; i < mid; ++i) {
+    let j = lastIndex - i;
+    let a = ls[i];
+    ls[i] = ls[j];
+    ls[j] = a;
+  }
+}
+// Implements extension method ListBuilder::set
+export function listBuilderSet(ls, i, newValue) {
+  let { length } = ls;
+  if (0 <= i && i <= length) {
+    ls[i] = newValue;
+  }
+  return; // of type tVoid
+}
+// Implements extension method ListBuilder::toList
+export function listBuilderToList(ls) {
+  return freeze(ls.slice());
+}
+// Implements extension method List::slice
+export function listSlice(ls, startInclusive, endExclusive) {
+  if (startInclusive < 0) { startInclusive = 0; }
+  if (endExclusive < 0) { endExclusive = 0; }
+  return freeze(ls.slice(startInclusive, endExclusive));
+}
+
+// Implements extension method Deque::constructor
+const DEQUE_NTAKEN = Symbol("Deque::nTaken");
+export function dequeConstructor() {
+  let deque = [];
+  Object.defineProperty(deque, DEQUE_NTAKEN, { value: 0, writable: true });
+  return deque;
+}
+// Implements extension method Deque::add
+export function dequeAdd(deque, element) {
+  deque.push(element);
+}
+// Implements extension method Deque::isEmpty
+export function dequeIsEmpty(deque) {
+  return deque.length === (deque[DEQUE_NTAKEN] || 0);
+}
+// Implements extension method Deque::removeFirst
+export function dequeRemoveFirst(deque) {
+  // https://gist.github.com/mikesamuel/444258e7005e8fc9534d9cf274b1df58
+  let nTaken = deque[DEQUE_NTAKEN];
+  let length = deque.length;
+  if (length === nTaken) {
+    deque[DEQUE_NTAKEN] = 0;
+    deque.length = 0;
+    throw noResultException;
+  }
+  let item = deque[nTaken];
+  let nShiftThreshhold = (length / 2) | 0;
+  if (nShiftThreshhold < 32) { nShiftThreshhold = 32; }
+  if (nTaken >= nShiftThreshhold) {
+    deque.splice(0, nTaken + 1);
+    deque[DEQUE_NTAKEN] = 0;
+  } else {
+    deque[nTaken] = undefined;
+    deque[DEQUE_NTAKEN] = nTaken + 1;
+  }
+  return item;
+}
+
+const ZERO_N = BigInt(0);
+const ONE_N = BigInt(1);
+class DenseBitVector {
+  #bits /* : BigInt */;
+
+  constructor() {
+    this.#bits = ZERO_N;
+  }
+
+  get(index) {
+    return (this.#bits & (ONE_N << BigInt(index))) !== ZERO_N;
+  }
+
+  set(index, newBitValue) {
+    let mask = ONE_N << BigInt(index);
+    this.#bits = newBitValue
+      ? (this.#bits | mask)
+      : (this.#bits & ~mask);
+  }
+
+  toString() {
+    return `${this.#bits}`;
+  }
+
+  valueOf() {
+    return this.#bits;
+  }
+
+  toJSON() {
+    return this.#bits;
+  }
+}
+
+// Implements extension method DenseBitVector::constructor
+export function denseBitVectorConstructor(capacity) {
+  return new DenseBitVector();
+}
+// Implements extension method DenseBitVector::get
+export function denseBitVectorGet(denseBitVector, index) {
+  return denseBitVector.get(index);
+}
+// Implements extension method DenseBitVector::set
+export function denseBitVectorSet(denseBitVector, index, newBitValue) {
+  return denseBitVector.set(index, newBitValue);
+}
+
+// Implements extension method Boolean::toString
+export function booleanToString(b) {
+  return b ? 'true' : 'false';
+}
+
+// Implements Symbol construction.
+export function symbolFor(text) {
+  return Symbol.for(text);
+}
+
+// Stubs out static property verification
+export function getStatic(typeGuard, symbol) {
+  return undefined; // TODO(bps, #780)
+}
+
+const String = "".constructor;
+const { isArray } = Array;
+const { isSafeInteger } = Number;
+const { trunc } = Math;
+
+export {
+  // Export reliable paths to JS builtins, so they can import them
+  // via an unambiguous name locally and not worry about masking.
+  isArray,
+  isSafeInteger,
+};
+
+// Export runtime value type checks used for safe casting
+
+export function requireIsArray(x) {
+  if (!isArray) { throw noResultException; }
+  return x;
+}
+
+export function requireInstanceOf(x, typeRequirement) {
+  if (!(x instanceof typeRequirement)) { throw noResultException; }
+  return x;
+}
+
+export function requireIsSafeInteger(x) {
+  if (!isSafeInteger(x)) { throw noResultException; }
+  return x;
+}
+
+export function requireSame(x, y) {
+  if (x !== y) { throw noResultException; }
+  return x;
+}
+
+export function requireTypeOf(x, typeOfString) {
+  if (typeof x !== typeOfString) { throw noResultException; }
+  return x;
+}
+
+// When we need a reference to builtin that normally we inline
+export function bitwiseAnd(a, b) { return a & b; }
+export function bitwiseOr(a, b) { return a | b; }
+export function booleanNegation(b) { return !b; }
+export function divDubDub(x, y) { return x / y; }
+export function divIntInt(x, y) {
+  const result = trunc(x / y);
+  if (!isSafeInteger(result)) { throw noResultException; }
+  /* not NaN or infinite */
+  return result;
+}
+export function minusDub(x) { return -x; }
+export function minusInt(x) { return -x; }
+export function minusDubDub(x, y) { return x - y; }
+export function minusIntInt(x, y) { return x - y; }
+export function plusDub(x) { return +x; }
+export function plusInt(x) { return +x; }
+export function plusDubDub(x, y) { return x + y; }
+export function plusIntInt(x, y) { return x + y; }
+export function timesDubDub(x, y) { return x * y; }
+export function timesIntInt(x, y) { return x * y; }
+export function strCat(...args) {
+  let s = '';
+  for (let arg of args) {
+    s += String(arg); // Does not throw on Symbols
+  }
+  return s
+}
+export function listify(...args) { return freeze(args); }
+export const genericCmp =
+  (a, b) => {
+    let d = 0;
+    let ta = typeof a;
+    let tb = typeof b;
+    if (ta !== tb) {
+      throw noResultException;
+    }
+    if (a !== b) {
+      if (ta === 'string') { // UTF-8 order for strings
+        const aLen = a.length,
+          bLen = b.length,
+          minLen = aLen < bLen ? aLen : bLen;
+        for (let i = 0; i < minLen;) {
+          let ca = a.codePointAt(i);
+          let cb = b.codePointAt(i);
+          d = ca - cb;
+          if (d) { break; }
+          i += ca < 0x10000 ? 1 : 2;
+        }
+        if (!d) {
+          d = aLen - bLen;
+        }
+      } else {
+        d = (a < b) ? -1 : 1;
+      }
+      // TODO: handle user-defined comparison
+    }
+    if (ta === 'number' && a === 0 && b === 0) {
+      // Need to sort -0 before 0, which requires converting to signed infinities
+      return genericCmp(1/a, 1/b);
+    }
+    return (d > 0) - (d < 0);
+  };
+export function genericLt(a, b) { return genericCmp(a, b) < 0; }
+export function genericLe(a, b) { return genericCmp(a, b) <= 0; }
+export function genericGt(a, b) { return genericCmp(a, b) > 0; }
+export function genericGe(a, b) { return genericCmp(a, b) >= 0; }
+export function genericEq(a, b) {
+  if (a === 0 && b === 0) {
+    // This sorts out the 0.0 neq to -0.0
+    return 1/a === 1/b
+  }
+  return a === b;
+}
+export function genericNe(a, b) {
+  if (a === 0 && b === 0) {
+    // This sorts out the 0.0 neq to -0.0
+    return 1/a !== 1/b
+  }
+  return a !== b;
+}
+export function fail() { throw noResultException; }
+export function print(a) {
+  console.log("%s", a);
+  return void 0;
+}
+export function nexter(f) {
+  return ((generator) => () => generator.next())(f());
+}

package/interface-types.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview
+ * Declares *InterfaceType* which allows exposing a Temper `interface` type
+ * as a type that user types can extend and which inter-operates with
+ * `instanceof`.
+ *
+ * User code may do
+ *
+ *     MyClass.implementedBy(AnInterface);
+ *
+ * to declare that `class MyClass implements AnInterface { ... }`.
+ *
+ * After that, members defined on *AnInterface* will be available via
+ * *MyClass*'s prototype and `new MyClass(...) instanceof AnInterface` will
+ * be true.
+ */
+
+export class InterfaceType {
+    constructor(name, members, supers, inheritanceDepth) {
+        /** Diagnostic string.  The name of the interface. */
+        this.name = name;
+        /**
+         * A list of [kind, propertyKey, value] triples that should be added to
+         * classes that implement this modulo overriding.
+         * Kind has type ("m" | "g" | "s") where "m" indicates a normal method
+         * whose name is key, "g" a getter for the property named key,
+         * and "s" a setter.
+         */
+        this.members = [...members];
+        /** interface types that are super-types of this */
+        this.supers = [...supers];
+        /**
+         * Computed by Temper compiler so that sub-type members can clobber
+         * super-type members but not otherwise.
+         */
+        this.inheritanceDepth = inheritanceDepth;
+        /** Presence `in` a value indicates sub-type. */
+        this.interfaceTag = Symbol(this.toString());
+    }
+
+    toString() { return `interface ${this.name}`; }
+
+    /** Invoked when user code does `value instanceof anInterfaceType`. */
+    [Symbol.hasInstance](x) {
+        return x && typeof x === 'object' && this.interfaceTag in x;
+    }
+
+    /** Called to declare a class implements this InterfaceType. */
+    implementedBy(classType) {
+        const memberMaps = InterfaceType.#memberMapsFor(classType);
+        classType.prototype[this.interfaceTag] = void 0;
+        const inheritanceDepth = this.inheritanceDepth;
+        for (const [kind, key, value] of this.members) {
+            const memberMap = memberMaps[kind];
+            const depth = memberMap.get(key);
+            if (typeof depth === 'undefined' || inheritanceDepth > depth) {
+                memberMap.set(key, inheritanceDepth);
+                const proto = classType.prototype;
+                const descriptor = Object.getOwnPropertyDescriptor(proto, key)
+                    || { configurable: true };
+                switch (kind) {
+                    case 'm':
+                       descriptor.value = value;
+                       break;
+                    case 'g':
+                       descriptor.get = value;
+                       break;
+                    case 's':
+                       descriptor.set = value;
+                       break;
+                }
+                Object.defineProperty(proto, key, descriptor);
+            }
+        }
+        for (const superType of this.supers) {
+            superType.implementedBy(classType);
+        }
+    }
+
+    static #memberMapsKey = Symbol('memberMaps');
+
+    static #memberMapsFor(classType) {
+        const memberMapsKey = InterfaceType.#memberMapsKey;
+        // Do not reuse super-class's member map
+        let maps = Object.hasOwnProperty.call(classType, memberMapsKey)
+            ? classType[memberMapsKey] : null;
+        if (!maps) {
+            maps = { m: new Map(), g: new Map(), s: new Map() };
+            classType[memberMapsKey] = maps;
+            // Walk prototypes.  Even though Temper does not allow class
+            // inheritance, this code may be used by JavaScript types that
+            // do, so flatten class members so that interfaces don't clobber
+            // class members.
+            // Except we treat interfaces as sub-types of Object, so stop
+            // before Object.prototype.  This allows an interface to override
+            // Object members like toString, valueOf, etc.
+            let prototype = classType.prototype;
+            while (prototype && prototype !== Object.prototype) {
+                for (const keys of [
+                    Object.getOwnPropertyNames(prototype),
+                    Object.getOwnPropertySymbols(prototype),
+                ]) {
+                    for (const key of keys) {
+                        const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+                        if ('value' in descriptor) {
+                            maps.m.set(key, Number.MAX_SAFE_INTEGER);
+                        }
+                        if (descriptor.get) {
+                            maps.g.set(key, Number.MAX_SAFE_INTEGER);
+                        }
+                        if (descriptor.set) {
+                            maps.s.set(key, Number.MAX_SAFE_INTEGER);
+                        }
+                    }
+                }
+                prototype = Object.getPrototypeOf(prototype);
+            }
+        }
+        return maps;
+    }
+}

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@temperlang/core",
+  "version": "0.0.3",
+  "description": "Runtime support for JS generated by Temper",
+  "main": "index.js",
+  "type": "module",
+  "author": "https://github.com/mikesamuel",
+  "license": "Apache-2.0"
+}

package/regex.js

@@ -0,0 +1,95 @@
+import {noResultException} from "./index.js";
+
+export function compiledRegexCompiledFoundIn(_, compiled, text) {
+  return compiled.test(text);
+}
+
+export function compiledRegexCompiledFind(_, compiled, text, regexRefs) {
+  const match = compiled.exec(text);
+  if (match === null) {
+    throw noResultException;
+  }
+  const { groups, indices: { groups: indexGroups } } = match;
+  // Find the begin indices in code points for all matched groups.
+  const rawBegins = [];
+  const defaultFull = !("full" in groups);
+  if (defaultFull) {
+    rawBegins.push({ name: "full", index: match.index });
+  }
+  for (const entry of Object.entries(indexGroups)) {
+    const [name, indices] = entry;
+    if (indices !== undefined) {
+      rawBegins.push({ name, index: indices[0] });
+    }
+  }
+  const begins = codePointIndices(text, rawBegins);
+  // Form the matches.
+  const Group = regexRefs.match.groups[0].constructor;
+  const resultGroups = [];
+  if (defaultFull) {
+    resultGroups.push(new Group("full", match[0], begins.full));
+  }
+  for (const entry of Object.entries(groups)) {
+    const [name, value] = entry;
+    resultGroups.push(new Group(name, value ?? "", begins[name] ?? -1));
+  }
+  return new regexRefs.match.constructor(Object.freeze(resultGroups));
+}
+
+function codePointIndices(text, unitNameIndexArray) {
+  // Follows logic from CodePointsStringSlice but simpler.
+  // Sort first for single pass O(m log m) + O(n) rather than O(m * n).
+  // TODO(tjp, regex): Can we presume we often receive them in sorted order?
+  unitNameIndexArray.sort((a, b) => a.index - b.index);
+  let unitCount = 0;
+  let codeCount = 0;
+  const codeIndices = {};
+  for (const unitNameIndex of unitNameIndexArray) {
+    const { name, index: unitIndex } = unitNameIndex;
+    while (unitCount < unitIndex) {
+      unitCount += text.codePointAt(unitCount) > 0xFFFF ? 2 : 1;
+      codeCount += 1;
+    }
+    codeIndices[name] = codeCount;
+  }
+  return codeIndices;
+}
+
+export function compiledRegexCompileFormatted(_, formatted) {
+  return new RegExp(formatted, "du"); // d:hasIndices, u:unicode
+}
+
+export function regexFormatterAdjustCodeSet(self, codeSet, regexRefs) {
+  if (codeSet.negated) {
+    let maxCode = codeSet.items.reduce(
+      (maxCode, item) => Math.max(maxCode, self.maxCode(item)) ?? 0, 0
+    );
+    if (maxCode < MIN_SUPPLEMENTAL_CP) {
+      // Add a bonus explicit surrogate pair to encourage js code points.
+      // Alternatively, we could construct the inverse positive set, but
+      // this ends up looking a bit more like the provided form.
+      if (codeSetBonus === null) {
+        // Any surrogate pair will do.
+        codeSetBonus = new regexRefs.codePoints.constructor("🌐");
+      }
+      return new regexRefs.orObject.constructor([
+        codeSetBonus,
+        new codeSet.constructor(
+          [codeSetBonus].concat(codeSet.items), true
+        ),
+      ]);
+    }
+  }
+  return codeSet;
+}
+
+export function regexFormatterPushCodeTo(_, out, code, insideCodeSet) {
+  // Ignore insideCodeSet for now.
+  // TODO(tjp, regex): Get fancier, including with work in Temper.
+  out.push(`\\u{${code.toString(16)}}`);
+}
+
+// Cached later for some approximate efficiency.
+let codeSetBonus = null;
+
+const MIN_SUPPLEMENTAL_CP = 0x10000;