pollyroll 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Irakli Iremashvili
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,323 @@
+# pollyroll
+
+Lightweight 3D dice for the web with zero runtime dependencies. It has a WebGL2 renderer and a
+deterministic physics engine, and rolls are result-first, so it works for multiplayer.
+
+- **Result-first.** Values are drawn before any physics runs. The simulation only animates the dice,
+  and a symmetry remap turns each settled die so its top face shows the value already chosen.
+- **Shared rolls.** A roll is a plain JSON `RollEvent`. Every client that plays the same event shows
+  the same values. Clients whose trays have the same shape also see the same motion.
+- **Small.** About 3 kB for the DOM-free core, about 18.4 kB for the renderer, physics, geometry, and
+  shaders, and under 1 kB for the React binding (min+gzip). It ships no asset files: geometry,
+  labels, patterns, and lighting are all generated in code.
+
+## Install
+
+```sh
+npm install pollyroll
+```
+
+`react` (≥ 18) is an optional peer dependency, needed only for `pollyroll/react`.
+
+## Entry points
+
+| Import             | Contents                                                           | Runs in        |
+| ------------------ | ------------------------------------------------------------------ | -------------- |
+| `pollyroll`        | Notation parser, `createRoll`, `evaluate`, `redact`, `isRollEvent` | Node, browsers |
+| `pollyroll/render` | `createDiceTray`, skins and presets                                | Browsers       |
+| `pollyroll/react`  | `useDiceTray` hook and `<DiceTray />` overlay                      | React          |
+
+## Quick start
+
+```ts
+import { createRoll } from 'pollyroll';
+import { createDiceTray } from 'pollyroll/render';
+
+const tray = createDiceTray(document.getElementById('table')!); // overlay canvas inside the element
+const event = createRoll('2d20kh1+5');
+const summary = await tray.playRoll(event); // resolves once every die has settled
+console.log(summary.total);
+```
+
+If the target is an `HTMLElement`, the tray adds a transparent canvas inside it. The canvas is
+absolutely positioned and ignores pointer events, so give the element `position: relative` (or any
+positioning). You can also pass an existing `<canvas>`.
+
+## Core (`pollyroll`)
+
+```ts
+parse(notation: string): RollAst;            // throws PollyrollSyntaxError { message, index }
+createRoll(notation, opts?): RollEvent;      // opts: { rng?, seed?, skin?, rollerId?, audience? }
+evaluate(event: RollEvent): RollSummary;     // { total | null, modifier, groups: [{ die, dice, kept, dropped, subtotal }] }
+redact(event: RollEvent): RollEvent;         // copy with every value set to null
+isRollEvent(input: unknown): input is RollEvent; // validates untrusted input, including bounds
+```
+
+### Notation
+
+Notation is case-insensitive and ignores whitespace.
+
+| Syntax                  | Meaning                                                         |
+| ----------------------- | --------------------------------------------------------------- |
+| `NdX`                   | N dice (1–100) of X ∈ 4, 6, 8, 10, 12, 20, 100; N defaults to 1 |
+| `d%`, `dF`              | d100; Fudge die (−1, 0, +1)                                     |
+| `+`, `-`, integers      | Add or subtract terms and constants                             |
+| `khN` `klN` `dhN` `dlN` | Keep or drop the highest or lowest N (N defaults to 1)          |
+| `kN`, `dN`              | `khN`, `dlN` (N defaults to 1)                                  |
+| `!`                     | Explode on the maximum, up to 10 extra waves                    |
+| `x`                     | `!`                                                             |
+| `adv`, `dis`            | `2d20kh1`, `2d20kl1`                                            |
+
+Limits are at most 20 terms, at most 200 dice before explosions, and inputs of at most 256
+characters. Examples: `2d20kh1+5`, `4d6dl1`, `3d6!`, `adv+3`, `1d%`, `4dF`.
+
+### `RollEvent` (wire format, `v: 1`)
+
+```ts
+interface RollEvent {
+  v: 1;
+  id: string; // crypto.randomUUID(); receivers dedupe on it
+  notation: string; // as entered
+  dice: Array<{ type: DieType; value: number | null; group: number; wave: number }>;
+  modifier: number; // sum of constant terms
+  seed: string; // 32 hex chars; derives every throw parameter
+  skin?: SkinRef;
+  rollerId?: string;
+  audience?: 'all' | 'dm' | string[];
+  createdAt: number;
+}
+```
+
+In each summary group, `dice` lists the group's values in event order, and `kept` and `dropped` are
+**indexes** into that `dice` array. For example, `2d20kh1` with `[7, 15]` gives
+`{ dice: [7, 15], kept: [1], dropped: [0], subtotal: 15 }`. Keep/drop ranks every die of the group,
+explosion dice included, and ties go to the lower index.
+
+The event never carries totals or kept/dropped dice; `evaluate(event)` derives them. `group` is the
+index of the dice term (constants are not counted). `wave` is 0 for the initial throw and 1 or more
+for explosions.
+
+## Renderer (`pollyroll/render`)
+
+```ts
+const tray = createDiceTray(target, {
+  skin: 'classic', // preset name or a Skin object
+  labelFont: 'system-ui',
+  dieScale: 2, // maximum die size; large rolls shrink to fit
+  shadows: true,
+  maxDpr: 2,
+  reducedMotion: 'auto', // 'auto' follows prefers-reduced-motion; 'always' | 'never'
+  fadeAfterMs: null, // number: fade the dice out after they settle
+  labels: { d6: ['⚀', '⚁', '⚂', '⚃', '⚄', '⚅'] }, // optional custom labels per die
+});
+
+tray.playRoll(event); // Promise<RollSummary>; a new roll replaces the previous dice
+tray.setSkin('obsidian');
+tray.setDieScale(1.5); // size for the next roll; dice on screen keep theirs
+tray.clear();
+tray.resize(); // also called automatically through ResizeObserver
+tray.dispose(); // releases every GPU resource and listener
+tray.supported; // false when WebGL2 is unavailable
+```
+
+Custom labels (`labels`) replace the stock text but keep the value mapping. Each array follows the
+die's natural order:
+
+- `d4` to `d20`: `'1'…'N'`.
+- `d10`, `d100ones`: digits `'0'…'9'`.
+- `d100tens`: `'00'…'90'`.
+- `dF`: three entries for −1, blank, and +1.
+
+The label font is the skin's `font` if it has one, otherwise `labelFont`. If the browser can't parse that font, the label falls back to `labelFont`, then `system-ui`.
+
+- **No WebGL2:** `playRoll` resolves immediately with the summary and draws nothing.
+- **Reduced motion:** the tray draws the settled dice without animating them and resolves
+  immediately.
+- **Die size:** `dieScale` (default 2) is the largest size a die is drawn at. A roll with many dice
+  shrinks in 0.05 steps until its dice fit the tray, so a single d20 shows at full size while 20d6
+  stays readable without overlapping. The size sets the walls as well as the drawing, so both sides
+  of a shared roll need the same `dieScale` and tray aspect to see identical motion.
+- **Superseded rolls:** if a roll is replaced, cleared, or disposed, its promise still resolves with
+  that roll's own summary. It never rejects in these cases.
+- **Dice limit:** at most 30 dice are animated per tray (a d100 counts as two). Dice beyond that
+  still count in the summary.
+- **Device pixel ratio:** capped at `maxDpr`. The frame loop stops once the dice settle, so an idle
+  tray costs nothing.
+
+### Skins
+
+```ts
+import {
+  classic,
+  obsidian,
+  brass,
+  oak,
+  sapphire,
+  ruby,
+  emerald,
+  amethyst,
+  topaz,
+  aquamarine,
+  smoke,
+  defineSkin,
+  registerSkin,
+} from 'pollyroll/render';
+
+registerSkin('table-red', defineSkin('ruby', { labelColor: '#fff' }));
+tray.setSkin('table-red');
+
+tray.setSkin({
+  material: 'plastic', // 'plastic' | 'metal' | 'wood' | 'glass' | 'stone' | 'gem' | MaterialParams
+  color: ['#204080', '#a0c0ff'], // solid or two-tone
+  labelColor: '#ffffff',
+  labelStyle: 'engraved', // 'engraved' | 'printed' | 'embossed'
+  pattern: 'marble', // 'none' | 'gradient' | 'speckle' | 'marble' | 'wood' | 'swirl' | { glsl }
+});
+```
+
+A custom pattern is a GLSL ES 3.00 function, `vec3 pattern(vec3 p, vec3 n, vec3 a, vec3 b)`, that
+works in object space and returns the base color. If it fails to compile, `setSkin` throws
+`PollyrollShaderError`, and its `log` holds the compiler output. For safety, `isRollEvent` rejects
+events whose inline skin carries custom GLSL. Register custom-pattern skins locally and send only
+their names.
+
+Presets: `classic`, `obsidian`, `brass`, `oak`, `sapphire` (glass), `ruby` (gem), `emerald`
+(glass), `amethyst` (gem), `topaz` (gem), `aquamarine` (clear glass), and `smoke` (smoky glass).
+
+`MaterialParams` takes `metalness`, `roughness`, and optional `clearcoat`, `transmission`, `tint`,
+and `sparkle`, all in [0, 1]. `transmission` above 0 makes the die see-through (higher is clearer),
+`tint` sets how deep the body colour gets along the view path, and `sparkle` adds gem glints.
+`'glass'` is `transmission: 0.8, tint: 0.6`; `'gem'` is `transmission: 0.4, tint: 0.9, sparkle: 1`.
+`materialPresets` (from `pollyroll/render`) gives the full params of every named material, a
+starting point for custom ones: `{ ...materialPresets.glass, tint: 0.3 }`.
+
+```ts
+tray.setSkin({
+  material: {
+    metalness: 0,
+    roughness: 0.06,
+    clearcoat: 1,
+    transmission: 0.7,
+    tint: 0.8,
+    sparkle: 0.5,
+  },
+  color: ['#0b5d3b', '#18a86b'],
+  labelColor: '#ffffff',
+  labelStyle: 'printed',
+});
+```
+
+## React (`pollyroll/react`)
+
+```tsx
+import { useRef } from 'react';
+import { createRoll } from 'pollyroll';
+import { DiceTray } from 'pollyroll/react';
+import type { DiceTray as Tray } from 'pollyroll/render';
+
+function Table() {
+  const tray = useRef<Tray | null>(null);
+  return (
+    <div style={{ position: 'relative', height: 480 }}>
+      <DiceTray trayRef={tray} skin="oak" />
+      <button onClick={() => tray.current?.playRoll(createRoll('1d20'))}>Roll</button>
+    </div>
+  );
+}
+```
+
+`useDiceTray(ref, opts)` creates a tray on `ref.current` after mount and disposes it exactly once on
+unmount, including under StrictMode. Options are read when the tray is created. Only `skin` updates
+afterwards, and object skins are compared by value.
+
+## Multiplayer
+
+The library never touches the network. Send the event over whatever channel you already have:
+
+```ts
+// roller
+const event = createRoll('1d20+4', { rollerId: me.id });
+// redact() nulls every value and drops explosion dice, so a hidden roll reveals nothing
+tray.playRoll(event);
+channel.send({ kind: 'dice', event: hidden ? redact(event) : event });
+
+// receivers
+channel.on('dice', ({ event }) => {
+  if (!isRollEvent(event) || seen.has(event.id)) return;
+  seen.add(event.id);
+  tray.playRoll(event); // redacted: blank labels, total null, explosion dice removed
+});
+```
+
+The throw is derived from `seed`, so receivers replay the same tumble. The values come from the
+event, so every receiver shows the same result. Motion matches exactly when both trays have the
+same quantized aspect ratio and `dieScale`.
+
+## Determinism
+
+The physics step uses only `+ − * /` and `Math.sqrt`, with a fixed 1/120 s step and fixed iteration
+order. The geometry and the tray bounds use algebraic constants instead of trigonometry. CI checks
+that Chromium, Firefox, and WebKit compute the same trajectory hash as Node.
+
+## Known limits
+
+These describe 0.1.0 as built. Each one is a deliberate trade-off or a measured edge case, not a
+hidden bug.
+
+**Physics and layout**
+
+- **Dice collide as spheres with each other.** Contact with the floor and walls uses the exact
+  shape, but die-to-die contact uses bounding spheres. Dice therefore stop a little apart and never
+  stack or lean on each other's faces.
+- **Large rolls get smaller dice.** Auto-fit shrinks a roll until its dice fit the tray (5 square
+  die-units per die). With many dice in a small canvas the dice get small, down to a floor of
+  0.5 × `dieScale`. Dice beyond 30 animated bodies are counted in the summary but not shown; a d100
+  counts as two bodies.
+- **30-dice rolls can overlap.** About 3–5 % of 30-dice rolls end with two dice touching. Rolls of
+  4, 9 and 20 dice showed no overlap in 150 test rolls each.
+- **The final settle skips collision checks.** For the last 0.2 s, a die that rested tilted or too
+  close to a neighbour is moved flat and apart without collision checks. In crowded rolls it can
+  briefly pass through a neighbour.
+- **Motion matches only between same-shape trays.** Two clients see identical motion when their
+  trays have the same aspect ratio and the same `dieScale`. The values always match, because the
+  remap runs on each client.
+- **Explosion waves add time.** Each wave is thrown after the previous one settles, so long
+  explosion chains (up to 10 waves) take several seconds.
+
+**Rendering**
+
+- **Camera:** the camera looks straight down (orthographic). There is no option for an angled view,
+  and dice in the air do not grow as they approach; the shadow offset carries the height cue.
+- **Small labels:** d4 and d20 labels are the smallest because of their face shapes. Raise
+  `dieScale` if they are hard to read.
+- **No images:** there are no image textures, and lighting is analytic.
+- **Shadows:** these are soft blobs, not shadow maps.
+- **What has been tested:** screenshot baselines come from SwiftShader in headless Chromium. Real
+  GPUs, mobile devices, and the 60 fps target under CPU throttling have not been measured yet.
+- **WebGL2 is required:** without it, `playRoll` resolves with the summary and draws nothing.
+
+**Notation and wire format**
+
+- **Not supported:** rerolls (`r1`), compounding explosions, success counting (`>=5`), crit ranges,
+  parentheses, `*` and `/`, and dice other than d4, d6, d8, d10, d12, d20, d100 and dF.
+- **Aliases:** `kN`, `dN` and `x` are accepted. An event that uses them is rejected by
+  `isRollEvent` in any build that predates the aliases.
+- **Custom GLSL stays local:** `isRollEvent` rejects inline custom GLSL, so share custom-pattern
+  skins by registered name.
+
+## Development
+
+```sh
+pnpm install
+pnpm dev        # demo playground
+pnpm verify     # lint, format, build, typecheck, tests with coverage, size budgets
+pnpm e2e        # Playwright (Chromium, Firefox, WebKit)
+pnpm bench      # physics benchmark
+```
+
+The build specification is in [docs/PLAN.md](docs/PLAN.md) and the decision log in
+[docs/DECISIONS.md](docs/DECISIONS.md).
+
+## License
+
+MIT

package/dist/chunk-JIYQHWUA.js

@@ -0,0 +1,243 @@
+// src/core/notation.ts
+var PollyrollSyntaxError = class extends Error {
+  index;
+  constructor(message, index) {
+    super(message);
+    this.name = "PollyrollSyntaxError";
+    this.index = index;
+  }
+};
+var MAX_LENGTH = 256;
+var MAX_TERMS = 20;
+var MAX_COUNT = 100;
+var MAX_DICE = 200;
+var MAX_CONSTANT = 999999;
+var WHITESPACE = /\s/;
+var SIZES = {
+  "4": "d4",
+  "6": "d6",
+  "8": "d8",
+  "10": "d10",
+  "12": "d12",
+  "20": "d20",
+  "100": "d100"
+};
+var isDigit = (c) => c >= "0" && c <= "9";
+function parse(notation) {
+  if (typeof notation !== "string") {
+    throw new PollyrollSyntaxError("Notation must be a string", 0);
+  }
+  if (notation.length > MAX_LENGTH) {
+    throw new PollyrollSyntaxError("Notation is longer than 256 characters", MAX_LENGTH);
+  }
+  const chars = [];
+  const origin = [];
+  for (let i = 0; i < notation.length; i++) {
+    const c = notation.charAt(i);
+    if (WHITESPACE.test(c)) continue;
+    chars.push(c >= "A" && c <= "Z" ? c.toLowerCase() : c);
+    origin.push(i);
+  }
+  if (chars.length === 0) {
+    throw new PollyrollSyntaxError("Notation is empty", 0);
+  }
+  let pos = 0;
+  const peek = (offset = 0) => chars[pos + offset] ?? "";
+  const word2 = (w) => chars.slice(pos, pos + w.length).join("") === w;
+  const fail = (message, at) => new PollyrollSyntaxError(message, origin[at] ?? notation.length);
+  const unexpected = () => {
+    const at = origin[pos];
+    return at === void 0 ? fail("Unexpected end of notation", pos) : fail(`Unexpected character "${notation.charAt(at)}"`, pos);
+  };
+  const digits = () => {
+    let s = "";
+    while (isDigit(peek())) {
+      s += peek();
+      pos++;
+    }
+    return s;
+  };
+  const parseDie = () => {
+    const c = peek();
+    if (c === "%" || c === "f") {
+      pos++;
+      return c === "%" ? "d100" : "dF";
+    }
+    if (!isDigit(c)) throw unexpected();
+    const sizeAt = pos;
+    const size = digits();
+    const die = SIZES[size];
+    if (!die) throw fail(`Unsupported die size d${size}`, sizeAt);
+    return die;
+  };
+  const parseTerm = (sign2) => {
+    if (word2("adv") || word2("dis")) {
+      const mode = peek() === "a" ? "kh" : "kl";
+      pos += 3;
+      return { kind: "dice", sign: sign2, count: 2, die: "d20", keep: { mode, n: 1 }, explode: false };
+    }
+    let count = 1;
+    if (isDigit(peek())) {
+      const countAt = pos;
+      count = Number(digits());
+      if (word2("adv") || word2("dis")) throw fail("adv and dis take no dice count", pos);
+      if (peek() !== "d") {
+        if (count > MAX_CONSTANT) throw fail("Constant is larger than 999999", countAt);
+        return { kind: "constant", sign: sign2, value: count };
+      }
+      if (count < 1 || count > MAX_COUNT) {
+        throw fail("Dice count must be between 1 and 100", countAt);
+      }
+    } else if (peek() !== "d") {
+      throw unexpected();
+    }
+    pos++;
+    const die = parseDie();
+    let keep = null;
+    let explode = false;
+    for (; ; ) {
+      const c = peek();
+      const next = peek(1);
+      if (c === "!" || c === "x") {
+        if (explode) throw fail("A term can explode only once", pos);
+        if (die === "dF") throw fail("Fudge dice cannot explode", pos);
+        explode = true;
+        pos++;
+      } else if (c === "k" || c === "d") {
+        if (keep) throw fail("A term can have only one keep or drop", pos);
+        const side = next === "h" || next === "l" ? next : c === "k" ? "h" : "l";
+        const mode = c === "k" ? side === "h" ? "kh" : "kl" : side === "h" ? "dh" : "dl";
+        let nAt = pos;
+        pos += next === side ? 2 : 1;
+        let n = 1;
+        if (isDigit(peek())) {
+          nAt = pos;
+          n = Number(digits());
+        }
+        if (n < 1 || n > count)
+          throw fail(`Keep or drop count must be between 1 and ${count}`, nAt);
+        keep = { mode, n };
+      } else {
+        break;
+      }
+    }
+    return { kind: "dice", sign: sign2, count, die, keep, explode };
+  };
+  const terms = [];
+  let total = 0;
+  let sign = 1;
+  if (peek() === "+" || peek() === "-") {
+    sign = peek() === "-" ? -1 : 1;
+    pos++;
+  }
+  for (; ; ) {
+    const start = pos;
+    const term = parseTerm(sign);
+    terms.push(term);
+    if (terms.length > MAX_TERMS) throw fail("Notation has more than 20 terms", start);
+    if (term.kind === "dice") {
+      total += term.count;
+      if (total > MAX_DICE) throw fail("Notation has more than 200 dice", start);
+    }
+    const c = peek();
+    if (c === "") break;
+    if (c !== "+" && c !== "-") throw unexpected();
+    sign = c === "-" ? -1 : 1;
+    pos++;
+  }
+  if (total === 0) {
+    throw new PollyrollSyntaxError("Notation has no dice", 0);
+  }
+  return { terms };
+}
+
+// src/core/evaluate.ts
+var ascending = (list) => list.map(([, i]) => i).sort((a, b) => a - b);
+function evaluate(event) {
+  const buckets = parse(event.notation).terms.filter((t) => t.kind === "dice").map((term) => ({ term, dice: [] }));
+  for (const die of event.dice) {
+    const bucket = buckets[die.group];
+    if (!bucket) throw new TypeError(`die group ${die.group} is out of range`);
+    bucket.dice.push(die.value);
+  }
+  let total = event.modifier;
+  const groups = buckets.map(({ term, dice }) => {
+    const pairs = [];
+    dice.forEach((v, i) => {
+      if (v !== null) pairs.push([v, i]);
+    });
+    if (pairs.length < dice.length) {
+      total = null;
+      return { die: term.die, dice, kept: [], dropped: [], subtotal: null };
+    }
+    let keep = pairs;
+    let drop = [];
+    if (term.keep) {
+      const { mode, n } = term.keep;
+      const dir = mode === "kh" || mode === "dh" ? -1 : 1;
+      const ranked = pairs.slice().sort(([va, a], [vb, b]) => dir * (va - vb) || a - b);
+      [keep, drop] = mode[0] === "k" ? [ranked.slice(0, n), ranked.slice(n)] : [ranked.slice(n), ranked.slice(0, n)];
+    }
+    let subtotal = 0;
+    for (const [v] of keep) subtotal += term.sign * v;
+    if (total !== null) total += subtotal;
+    return { die: term.die, dice, kept: ascending(keep), dropped: ascending(drop), subtotal };
+  });
+  return { total, modifier: event.modifier, groups };
+}
+
+// src/core/rng.ts
+var TWO_32 = 2 ** 32;
+var SEED_PATTERN = /^[0-9a-f]{32}$/;
+var word = new Uint32Array(1);
+function rejectionInt(max, draw) {
+  if (!Number.isInteger(max) || max < 1 || max > TWO_32) {
+    throw new RangeError(`maxExclusive must be an integer in [1, 2^32], got ${max}`);
+  }
+  const limit = TWO_32 - TWO_32 % max;
+  let u = draw();
+  while (u >= limit) u = draw();
+  return u % max;
+}
+function cryptoInt(maxExclusive) {
+  return rejectionInt(maxExclusive, () => {
+    let u = 0;
+    for (const w of globalThis.crypto.getRandomValues(word)) u = w;
+    return u;
+  });
+}
+function generateSeed() {
+  const words = globalThis.crypto.getRandomValues(new Uint32Array(4));
+  let seed = "";
+  for (const w of words) seed += w.toString(16).padStart(8, "0");
+  return seed;
+}
+function isSeed(value) {
+  return typeof value === "string" && SEED_PATTERN.test(value);
+}
+function createSeedRng(seed) {
+  if (!isSeed(seed)) throw new TypeError("seed must be 32 lowercase hex characters");
+  const part = (i) => parseInt(seed.slice(i * 8, i * 8 + 8), 16) | 0;
+  let a = part(0);
+  let b = part(1);
+  let c = part(2);
+  let d = part(3);
+  const u32 = () => {
+    let t = a + b | 0;
+    a = b ^ b >>> 9;
+    b = c + (c << 3) | 0;
+    c = c << 21 | c >>> 11;
+    d = d + 1 | 0;
+    t = t + d | 0;
+    c = c + t | 0;
+    return t >>> 0;
+  };
+  for (let i = 0; i < 12; i++) u32();
+  return {
+    u32,
+    float: () => u32() / TWO_32,
+    int: (maxExclusive) => rejectionInt(maxExclusive, u32)
+  };
+}
+
+export { PollyrollSyntaxError, createSeedRng, cryptoInt, evaluate, generateSeed, isSeed, parse };