@takram/three-geospatial 0.0.1-alpha.4 → 0.0.1-alpha.6

package/src/index.ts

@@ -1,16 +1,7 @@
-/// <reference types="vite-plugin-glsl/ext" />
-
-import depth from './shaders/depth.glsl'
-import packing from './shaders/packing.glsl'
-import transform from './shaders/transform.glsl'
-
-export const depthShader: string = depth
-export const packingShader: string = packing
-export const transformShader: string = transform
-
 export * from './ArrayBufferLoader'
 export * from './assertions'
 export * from './bufferGeometry'
+export * from './constants'
 export * from './DataLoader'
 export * from './Ellipsoid'
 export * from './EllipsoidGeometry'
@@ -18,8 +9,11 @@ export * from './Geodetic'
 export * from './math'
 export * from './PointOfView'
 export * from './Rectangle'
+export * from './resolveIncludes'
 export * from './TileCoordinate'
 export * from './TilingScheme'
 export * from './typedArray'
 export * from './TypedArrayLoader'
+export * from './typedArrayParsers'
 export * from './types'
+export * from './unrollLoops'

package/src/math.ts

@@ -10,6 +10,7 @@ export const isPowerOfTwo = MathUtils.isPowerOfTwo
 export const ceilPowerOfTwo = MathUtils.ceilPowerOfTwo
 export const floorPowerOfTwo = MathUtils.floorPowerOfTwo
 export const normalize = MathUtils.normalize
+export const remap = MathUtils.mapLinear
 
 // Prefer glsl's argument order which differs from that of MathUtils.
 export function smoothstep(min: number, max: number, x: number): number {

package/src/r3f/index.ts

@@ -1,2 +1,3 @@
 export * from './EastNorthUpFrame'
 export * from './EllipsoidMesh'
+export * from './types'

package/src/r3f/types.ts

@@ -0,0 +1,64 @@
+import {
+  type Color,
+  type ExtendedColors,
+  type NodeProps,
+  type Overwrite,
+  type Vector2,
+  type Vector3,
+  type Vector4
+} from '@react-three/fiber'
+import {
+  type Vector2 as Vector2Impl,
+  type Vector3 as Vector3Impl,
+  type Vector4 as Vector4Impl
+} from 'three'
+import { type WritableKeysOf } from 'type-fest'
+
+import { type Callable } from '../types'
+
+// prettier-ignore
+export type ExtendedVectors<T> = {
+  [K in keyof T]:
+    Vector2Impl extends T[K] ? Vector2 | T[K] :
+    Vector3Impl extends T[K] ? Vector3 | T[K] :
+    Vector4Impl extends T[K] ? Vector4 | T[K] :
+    T[K]
+}
+
+export type ExtendedProps<T> = ExtendedColors<ExtendedVectors<T>>
+
+// @react-three/fiber's NonFunctionKeys cannot exclude partial functions.
+// This excludes callback properties, which may be undesirable behavior.
+type NonFunctionKeys<T> = keyof {
+  [K in keyof T as Callable extends T[K] ? never : K]: any
+}
+
+// prettier-ignore
+type WritableNonExtendableKeysOf<T> =
+  | WritableKeysOf<T>
+  | keyof {
+      [K in keyof T as
+        Vector2Impl extends T[K] ? K :
+        Vector3Impl extends T[K] ? K :
+        Vector4Impl extends T[K] ? K :
+        Color extends T[K] ? K :
+        never
+      ]: any
+    }
+
+export type PassThoughInstanceProps<
+  RefType,
+  Args extends readonly any[],
+  Props
+> = Overwrite<
+  ExtendedProps<{
+    [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props>
+      ? K
+      : never]: Props[K]
+  }>,
+  NodeProps<RefType, Args>
+>
+
+export type ExpandNestedProps<T, Prop extends keyof T & string> = {
+  [K in keyof T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K]
+}

package/src/resolveIncludes.test.ts

@@ -0,0 +1,21 @@
+import { resolveIncludes } from './resolveIncludes'
+
+describe('resolveIncludes', () => {
+  test('delimited paths', () => {
+    expect(
+      resolveIncludes('#include "scope/lib"', {
+        scope: {
+          lib: 'imported'
+        }
+      })
+    ).toBe('imported')
+
+    expect(() =>
+      resolveIncludes('#include "scope/lib"', {
+        other: {
+          lib: 'imported'
+        }
+      })
+    ).toThrow()
+  })
+})

package/src/resolveIncludes.ts

@@ -0,0 +1,22 @@
+const includePattern = /^[ \t]*#include +"([\w\d./]+)"/gm
+
+interface Includes {
+  [key: string]: string | Includes
+}
+
+export function resolveIncludes(source: string, includes: Includes): string {
+  return source.replace(includePattern, (match, path: string) => {
+    const components = path.split('/')
+    const include = components.reduce<string | Includes | undefined>(
+      (parent, component) =>
+        typeof parent !== 'string' && parent != null
+          ? parent[component]
+          : undefined,
+      includes
+    )
+    if (typeof include !== 'string') {
+      throw new Error(`Could not find include for ${path}.`)
+    }
+    return resolveIncludes(include, includes)
+  })
+}

package/src/shaders/depth.glsl

@@ -1,10 +1,12 @@
+// cSpell:words logdepthbuf
+
 float reverseLogDepth(const float depth, const float near, const float far) {
   #ifdef USE_LOGDEPTHBUF
   float d = pow(2.0, depth * log2(far + 1.0)) - 1.0;
   float a = far / (far - near);
   float b = far * near / (near - far);
   return a + b / d;
-  #else
+  #else // USE_LOGDEPTHBUF
   return depth;
   #endif // USE_LOGDEPTHBUF
 }

package/src/shaders/generators.glsl

@@ -0,0 +1,9 @@
+float checker(const vec2 uv, const vec2 repeats) {
+  vec2 c = floor(repeats * uv);
+  float result = mod(c.x + c.y, 2.0);
+  return sign(result);
+}
+
+float checker(const vec2 uv, const float repeats) {
+  return checker(uv, vec2(repeats));
+}

package/src/shaders/index.ts

@@ -0,0 +1,17 @@
+import _depth from './depth.glsl?raw'
+import _generators from './generators.glsl?raw'
+import _math from './math.glsl?raw'
+import _packing from './packing.glsl?raw'
+import _poissonDisk from './poissonDisk.glsl?raw'
+import _raySphereIntersection from './raySphereIntersection.glsl?raw'
+import _transform from './transform.glsl?raw'
+import _turbo from './turbo.glsl?raw'
+
+export const depth: string = _depth
+export const generators: string = _generators
+export const math: string = _math
+export const packing: string = _packing
+export const poissonDisk: string = _poissonDisk
+export const raySphereIntersection: string = _raySphereIntersection
+export const transform: string = _transform
+export const turbo: string = _turbo

package/src/shaders/math.glsl

@@ -0,0 +1,52 @@
+#if !defined(saturate)
+#define saturate(a) clamp(a, 0.0, 1.0)
+#endif // !defined(saturate)
+
+float inverseLerp(const float x, const float y, const float a) {
+  return (a - x) / (y - x);
+}
+
+vec2 inverseLerp(const vec2 x, const vec2 y, const vec2 a) {
+  return (a - x) / (y - x);
+}
+
+vec3 inverseLerp(const vec3 x, const vec3 y, const vec3 a) {
+  return (a - x) / (y - x);
+}
+
+vec4 inverseLerp(const vec4 x, const vec4 y, const vec4 a) {
+  return (a - x) / (y - x);
+}
+
+float remap(const float x, const float min1, const float max1, const float min2, const float max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec2 remap(const vec2 x, const vec2 min1, const vec2 max1, const vec2 min2, const vec2 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec3 remap(const vec3 x, const vec3 min1, const vec3 max1, const vec3 min2, const vec3 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec4 remap(const vec4 x, const vec4 min1, const vec4 max1, const vec4 min2, const vec4 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+// Implicitly remap to 0 and 1
+float remap(const float x, const float min1, const float max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec2 remap(const vec2 x, const vec2 min1, const vec2 max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec3 remap(const vec3 x, const vec3 min1, const vec3 max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec4 remap(const vec4 x, const vec4 min1, const vec4 max1) {
+  return (x - min1) / (max1 - min1);
+}

package/src/shaders/poissonDisk.glsl

@@ -0,0 +1,21 @@
+// Taken from: https://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
+const vec2 poissonDisk[16] = vec2[16](
+  vec2(-0.94201624, -0.39906216),
+  vec2(0.94558609, -0.76890725),
+  vec2(-0.094184101, -0.9293887),
+  vec2(0.34495938, 0.2938776),
+  vec2(-0.91588581, 0.45771432),
+  vec2(-0.81544232, -0.87912464),
+  vec2(-0.38277543, 0.27676845),
+  vec2(0.97484398, 0.75648379),
+  vec2(0.44323325, -0.97511554),
+  vec2(0.53742981, -0.4737342),
+  vec2(-0.26496911, -0.41893023),
+  vec2(0.79197514, 0.19090188),
+  vec2(-0.2418884, 0.99706507),
+  vec2(-0.81409955, 0.9143759),
+  vec2(0.19984126, 0.78641367),
+  vec2(0.14383161, -0.1410079)
+);
+
+#define POISSON_DISK_COUNT (16)

package/src/shaders/raySphereIntersection.glsl

@@ -0,0 +1,134 @@
+float raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b - sqrt(discriminant)) * 0.5;
+}
+
+float raySphereFirstIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b - sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereFirstIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+float raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b + sqrt(discriminant)) * 0.5;
+}
+
+float raySphereSecondIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b + sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereSecondIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  if (discriminant < 0.0) {
+    intersection1 = -1.0;
+    intersection2 = -1.0;
+    return;
+  } else {
+    float Q = sqrt(discriminant);
+    intersection1 = (-b - Q) * 0.5;
+    intersection2 = (-b + Q) * 0.5;
+  }
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  vec4 Q = sqrt(max(vec4(0.0), discriminant));
+  intersection1 = mix((-b - Q) * 0.5, vec4(-1.0), mask);
+  intersection2 = mix((-b + Q) * 0.5, vec4(-1.0), mask);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}

package/src/shaders/turbo.glsl

@@ -0,0 +1,9 @@
+// A fifth-order polynomial approximation of Turbo color map.
+// See: https://observablehq.com/@mbostock/turbo
+// prettier-ignore
+vec3 turbo(const float x) {
+  float r = 0.1357 + x * (4.5974 - x * (42.3277 - x * (130.5887 - x * (150.5666 - x * 58.1375))));
+  float g = 0.0914 + x * (2.1856 + x * (4.8052 - x * (14.0195 - x * (4.2109 + x * 2.7747))));
+  float b = 0.1067 + x * (12.5925 - x * (60.1097 - x * (109.0745 - x * (88.5066 - x * 26.8183))));
+  return vec3(r, g, b);
+}

package/src/typedArray.ts

@@ -1,3 +1,5 @@
+import invariant from 'tiny-invariant'
+
 export type TypedArray =
   | Int8Array
   | Uint8Array
@@ -20,57 +22,32 @@ export type TypedArrayConstructor =
   | Float32ArrayConstructor
   | Float64ArrayConstructor
 
-type GetValue = keyof {
-  [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
-    ? K
-    : never]: DataView[K]
-}
-
-export function parseTypedArray<
-  T extends TypedArrayConstructor,
-  K extends GetValue
->(
-  buffer: ArrayBuffer,
-  TypedArray: T,
-  getValue: K,
-  littleEndian?: boolean
-): InstanceType<T>
-
-export function parseTypedArray<K extends GetValue>(
-  buffer: ArrayBuffer,
-  TypedArray: TypedArrayConstructor,
-  getValue: K,
-  littleEndian = true
-): TypedArray {
-  const data = new DataView(buffer)
-  const array = new TypedArray(data.byteLength / TypedArray.BYTES_PER_ELEMENT)
-  for (
-    let index = 0, byteIndex = 0;
-    index < array.length;
-    ++index, byteIndex += TypedArray.BYTES_PER_ELEMENT
-  ) {
-    array[index] = data[getValue](byteIndex, littleEndian)
-  }
-  return array
-}
-
-export function parseInt16Array(
-  buffer: ArrayBuffer,
-  littleEndian?: boolean
-): Int16Array {
-  return parseTypedArray(buffer, Int16Array, 'getInt16', littleEndian)
-}
-
-export function parseUint16Array(
-  buffer: ArrayBuffer,
-  littleEndian?: boolean
-): Uint16Array {
-  return parseTypedArray(buffer, Uint16Array, 'getUint16', littleEndian)
-}
+export type TypedArrayElementType =
+  | 'int8'
+  | 'uint8'
+  | 'int16'
+  | 'uint16'
+  | 'int32'
+  | 'uint32'
+  | 'float32'
+  | 'float64'
 
-export function parseFloat32Array(
-  buffer: ArrayBuffer,
-  littleEndian?: boolean
-): Float32Array {
-  return parseTypedArray(buffer, Float32Array, 'getFloat32', littleEndian)
+export function getTypedArrayElementType(
+  array: TypedArray
+): TypedArrayElementType {
+  // prettier-ignore
+  const type = (
+    array instanceof Int8Array ? 'int8' :
+    array instanceof Uint8Array ? 'uint8' :
+    array instanceof Uint8ClampedArray ? 'uint8' :
+    array instanceof Int16Array ? 'int16' :
+    array instanceof Uint16Array ? 'uint16' :
+    array instanceof Int32Array ? 'int32' :
+    array instanceof Uint32Array ? 'uint32' :
+    array instanceof Float32Array ? 'float32' :
+    array instanceof Float64Array ? 'float64' :
+    null
+  )
+  invariant(type != null)
+  return type
 }

package/src/typedArrayParsers.ts

@@ -0,0 +1,77 @@
+import { type TypedArray, type TypedArrayConstructor } from './typedArray'
+
+type GetValue = keyof {
+  [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
+    ? K
+    : never]: DataView[K]
+}
+
+function parseTypedArray<T extends TypedArrayConstructor, K extends GetValue>(
+  buffer: ArrayBuffer,
+  TypedArray: T,
+  getValue: K,
+  littleEndian?: boolean
+): InstanceType<T>
+
+function parseTypedArray<K extends GetValue>(
+  buffer: ArrayBuffer,
+  TypedArray: TypedArrayConstructor,
+  getValue: K,
+  littleEndian = true
+): TypedArray {
+  const data = new DataView(buffer)
+  const array = new TypedArray(data.byteLength / TypedArray.BYTES_PER_ELEMENT)
+  for (
+    let index = 0, byteIndex = 0;
+    index < array.length;
+    ++index, byteIndex += TypedArray.BYTES_PER_ELEMENT
+  ) {
+    array[index] = data[getValue](byteIndex, littleEndian)
+  }
+  return array
+}
+
+export type TypedArrayParser<T extends TypedArray> = (
+  buffer: ArrayBuffer,
+  littleEndian?: boolean
+) => T
+
+export const parseUint8Array: TypedArrayParser<Uint8Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint8Array, 'getUint8', littleEndian)
+
+export const parseInt8Array: TypedArrayParser<Int8Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int8Array, 'getInt8', littleEndian)
+
+export const parseUint16Array: TypedArrayParser<Uint16Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint16Array, 'getUint16', littleEndian)
+
+export const parseInt16Array: TypedArrayParser<Int16Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int16Array, 'getInt16', littleEndian)
+
+export const parseInt32Array: TypedArrayParser<Int32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Int32Array, 'getInt32', littleEndian)
+
+export const parseUint32Array: TypedArrayParser<Uint32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Uint32Array, 'getUint32', littleEndian)
+
+export const parseFloat32Array: TypedArrayParser<Float32Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Float32Array, 'getFloat32', littleEndian)
+
+export const parseFloat64Array: TypedArrayParser<Float64Array> = (
+  buffer,
+  littleEndian
+) => parseTypedArray(buffer, Float64Array, 'getFloat64', littleEndian)

package/src/types.ts

@@ -1,54 +1,8 @@
-import {
-  type Matrix2,
-  type Matrix3,
-  type Matrix4,
-  type Vector2,
-  type Vector3,
-  type Vector4
-} from 'three'
-import { type ReadonlyTuple } from 'type-fest'
+import { type Uniform } from 'three'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Callable = (...args: any) => any
 
-export type ReadonlyTuple2<T = number> = ReadonlyTuple<T, 2>
-export type ReadonlyTuple3<T = number> = ReadonlyTuple<T, 3>
-export type ReadonlyTuple4<T = number> = ReadonlyTuple<T, 4>
-
-// Non-readonly version of ReadonlyTuple. This is not type-safe because mutable
-// methods still exist in the type.
-// See https://github.com/sindresorhus/type-fest/blob/main/source/readonly-tuple.d.ts
-type BuildTupleHelper<
-  Element,
-  Length extends number,
-  Rest extends Element[]
-> = Rest['length'] extends Length
-  ? [...Rest]
-  : BuildTupleHelper<Element, Length, [Element, ...Rest]>
-
-export type Tuple<T, Length extends number> = number extends Length
-  ? readonly T[]
-  : BuildTupleHelper<T, Length, []>
-
-export type Tuple2<T = number> = BuildTupleHelper<T, 2, []>
-export type Tuple3<T = number> = BuildTupleHelper<T, 3, []>
-export type Tuple4<T = number> = BuildTupleHelper<T, 4, []>
-
-// Suppose return type of the mutable methods of classes like Vector3 is `this`.
-// TODO: How can we specify `this` as a constraint?
-type ReadonlyThreeInstance<T> = Readonly<{
-  [K in keyof T as T[K] extends Callable
-    ? ReturnType<T[K]> extends T
-      ? K extends 'clone'
-        ? K
-        : never
-      : K
-    : K]: T[K]
-}>
-
-export type ReadonlyVector2 = ReadonlyThreeInstance<Vector2>
-export type ReadonlyVector3 = ReadonlyThreeInstance<Vector3>
-export type ReadonlyVector4 = ReadonlyThreeInstance<Vector4>
-export type ReadonlyMatrix2 = ReadonlyThreeInstance<Matrix2>
-export type ReadonlyMatrix3 = ReadonlyThreeInstance<Matrix3>
-export type ReadonlyMatrix4 = ReadonlyThreeInstance<Matrix4>
+export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
+  get: <K extends keyof T>(key: K) => T[K]
+  set: <K extends keyof T>(key: K, value: T[K]) => void
+}

package/src/unrollLoops.ts

@@ -0,0 +1,23 @@
+// Based on: https://github.com/mrdoob/three.js/blob/r170/src/renderers/webgl/WebGLProgram.js#L294
+
+const unrollLoopPattern =
+  /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*(?:i\s*\+\+|\+\+\s*i)\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g
+
+function loopReplacer(
+  match: string,
+  start: string,
+  end: string,
+  snippet: string
+): string {
+  let string = ''
+  for (let i = parseInt(start); i < parseInt(end); ++i) {
+    string += snippet
+      .replace(/\[\s*i\s*\]/g, '[' + i + ']')
+      .replace(/UNROLLED_LOOP_INDEX/g, `${i}`)
+  }
+  return string
+}
+
+export function unrollLoops(string: string): string {
+  return string.replace(unrollLoopPattern, loopReplacer)
+}