@luma.gl/webgl 8.5.10 → 8.6.0-alpha.4

package/src/debug/{debug-uniforms.js → debug-uniforms.ts}

@@ -1,14 +1,24 @@
-import {assert} from '../utils/assert';
-import {formatValue} from '../utils/format-value';
+import {assert, formatValue} from '@luma.gl/api';
 
 // Prepares a table suitable for console.table
 /* eslint-disable max-statements, complexity */
-export function getDebugTableForUniforms({
-  header = 'Uniforms',
-  program,
-  uniforms,
-  undefinedOnly = false
-}) {
+export function getDebugTableForUniforms(options?: {
+  header?: string;
+  program: any;
+  uniforms: any;
+  undefinedOnly?: boolean;
+}): {
+  table: {};
+  count: number;
+  unusedTable: {};
+  unusedCount: number;
+} {
+  const {
+    header = 'Uniforms',
+    program,
+    uniforms,
+    undefinedOnly = false
+  } = options;
   assert(program);
 
   const SHADER_MODULE_UNIFORM_REGEXP = '.*_.*';

package/src/debug/{debug-vertex-array.js → debug-vertex-array.ts}

@@ -1,10 +1,12 @@
-import Buffer from '../classes/buffer';
+import {formatValue} from '@luma.gl/api';
+import Buffer from '../classes/webgl-buffer';
 import {getKey} from '../webgl-utils/constants-to-keys';
 import {getCompositeGLType} from '../webgl-utils/attribute-utils';
-import {formatValue} from '../utils/format-value';
 
 // Creates object suitable as input for console.table
-export function getDebugTableForVertexArray({vertexArray, header = 'Attributes'}) {
+export function getDebugTableForVertexArray(options?: {vertexArray: any; header?: string}): {} {
+  const {vertexArray, header = 'Attributes'} = options;
+
   if (!vertexArray.configuration) {
     return {};
   }
@@ -14,6 +16,7 @@ export function getDebugTableForVertexArray({vertexArray, header = 'Attributes'}
   // Add index (elements) if available
   if (vertexArray.elements) {
     // const elements = Object.assign({size: 1}, vertexArray.elements);
+    // @ts-expect-error
     table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header);
   }
 
@@ -78,9 +81,7 @@ function getDebugTableRow(vertexArray, attribute, accessor, header) {
     marker = changed ? '*' : '';
 
     value = data;
-    // @ts-ignore
     bytes = buffer.byteLength;
-    // @ts-ignore
     verts = bytes / data.BYTES_PER_ELEMENT / size;
 
     let format;

package/src/helpers/get-program-bindings.ts

@@ -0,0 +1,244 @@
+import GL from '@luma.gl/constants';
+import {isWebGL2} from '../context/context/webgl-checks';
+import {ProgramBindings, AttributeBinding, UniformBinding, UniformBlockBinding, VaryingBinding} from './program-bindings'
+import Accessor from '../classes/accessor';
+import {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';
+
+/**
+ * Extract metadata describing binding information for a program's shaders
+ * Note: `linkProgram()` needs to have been called
+ * (although linking does not need to have been successful).
+*/
+export function getProgramBindings(gl: WebGL2RenderingContext, program: WebGLProgram): ProgramBindings {
+  const config: ProgramBindings = {
+    attributes: readAttributeBindings(gl, program),
+    uniforms: readUniformBindings(gl, program),
+    uniformBlocks: readUniformBlocks(gl, program),
+    varyings: readVaryings(gl, program)
+  };
+
+  Object.seal(config);
+  return config;
+  // generateWebGPUStyleBindings(bindings);
+}
+
+
+/**
+ * Extract info about all transform feedback varyings
+ *
+ * linkProgram needs to have been called, although linking does not need to have been successful
+ */
+function readAttributeBindings(gl: WebGL2RenderingContext, program: WebGLProgram): AttributeBinding[] {
+  const attributes: AttributeBinding[] = [];
+
+  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+
+  for (let index = 0; index < count; index++) {
+    const {name, type: compositeType, size} = gl.getActiveAttrib(program, index);
+    const location = gl.getAttribLocation(program, name);
+    // Add only user provided attributes, for built-in attributes like
+    // `gl_InstanceID` locaiton will be < 0
+    if (location >= 0) {
+      const {type, components} = decomposeCompositeGLType(compositeType);
+      const accessor = {type, size: size * components};
+      inferProperties(location, name, accessor);
+    
+      const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values
+      attributes.push(attributeInfo);
+    }
+  }
+
+  attributes.sort((a, b) => a.location - b.location);
+  return attributes;
+}
+
+/**
+ * Extract info about all transform feedback varyings
+ *
+ * linkProgram needs to have been called, although linking does not need to have been successful
+ */
+function readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {
+  if (!isWebGL2(gl)) {
+    return [];
+  }
+
+  const varyings = [];
+
+  const count = gl.getProgramParameter(program, gl.TRANSFORM_FEEDBACK_VARYINGS);
+  for (let location = 0; location < count; location++) {
+    const {name, type: compositeType, size} = gl.getTransformFeedbackVarying(program, location);
+    const {type, components} = decomposeCompositeGLType(compositeType);
+    const accessor = new Accessor({type, size: size * components});
+    const varying = {location, name, accessor}; // Base values
+    varyings.push(varying);
+  }
+
+  varyings.sort((a, b) => a.location - b.location);
+  return varyings;
+}
+
+/**
+ * Extract info about all uniforms
+ *
+ * Query uniform locations and build name to setter map.
+ */
+function readUniformBindings(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {
+  const uniforms: UniformBinding[] = [];
+
+  const uniformCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+  for (let i = 0; i < uniformCount; i++) {
+    const {name: rawName, size, type} = gl.getActiveUniform(program, i);
+    const {name, isArray} = parseUniformName(rawName);
+    let webglLocation = gl.getUniformLocation(program, name);
+    const uniformInfo = {
+      // WebGL locations are uniquely typed but just numbers
+      location: webglLocation as number,
+      name,
+      size,
+      type,
+      isArray
+    };
+    uniforms.push(uniformInfo);
+
+    // Array (e.g. matrix) uniforms can occupy several 4x4 byte banks
+    if (uniformInfo.size > 1) {
+      for (let j = 0; j < uniformInfo.size; j++) {
+        const elementName = `${name}[${j}]`;
+
+        webglLocation = gl.getUniformLocation(program, elementName);
+
+        const arrayElementUniformInfo = {
+          ...uniformInfo,
+          name: elementName,
+          location: webglLocation as number
+        };
+
+        uniforms.push(arrayElementUniformInfo);
+      }
+    }
+  }
+  return uniforms;
+}
+
+/**
+ * Extract info about all "active" uniform blocks
+ *
+ * ("Active" just means that unused (aka inactive) blocks may have been
+ * optimized away during linking)
+ */
+function readUniformBlocks(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBlockBinding[] {
+  const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
+
+  const uniformBlocks: UniformBlockBinding[] = [];
+
+  const blockCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
+  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+
+    const blockInfo = {
+      name: gl.getActiveUniformBlockName(program, blockIndex),
+      location: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_BINDING),
+      byteLength: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
+      vertex: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+      fragment: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+      uniformCount: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      uniformIndices: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
+      uniforms: []
+    }
+
+    for (let uniformIndex = 0; uniformIndex < blockInfo.uniformCount; ++uniformIndex) {
+      // TODO - Can we extract more?
+    }
+
+    uniformBlocks.push(blockInfo);
+  }
+
+  uniformBlocks.sort((a, b) => a.location - b.location);
+  return uniformBlocks;
+}
+
+const SAMPLER_UNIFORMS_GL_TO_GPU = {
+  [GL.SAMPLER_2D]: ['2d', 'float'],
+  [GL.SAMPLER_CUBE]: ['cube', 'float'],
+  [GL.SAMPLER_3D]: ['3d', 'float'],
+  [GL.SAMPLER_2D_SHADOW]: ['3d', 'depth'],
+  [GL.SAMPLER_2D_ARRAY]: ['2d-array', 'float'],
+  [GL.SAMPLER_2D_ARRAY_SHADOW]: ['2d-array', 'depth'],
+  [GL.SAMPLER_CUBE_SHADOW]: ['cube', 'float'],
+  [GL.INT_SAMPLER_2D]: ['2d', 'sint'],
+  [GL.INT_SAMPLER_3D]: ['3d', 'sint'],
+  [GL.INT_SAMPLER_CUBE]: ['cube', 'sint'],
+  [GL.INT_SAMPLER_2D_ARRAY]: ['2d-array', 'sint'],
+  [GL.UNSIGNED_INT_SAMPLER_2D]: ['2d', 'sint'],
+  [GL.UNSIGNED_INT_SAMPLER_3D]: ['3d', 'sint'],
+  [GL.UNSIGNED_INT_SAMPLER_CUBE]: ['cube', 'sint'],
+  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'sint']
+};
+
+/**
+ * Generate a list of "WebGPU-style" bindings for this program
+ */
+function generateWebGPUStyleBindings(config: ProgramBindings) {
+  const bindings: any = [];
+
+  // Uniform blocks
+  for (const blockInfo of config.uniformBlocks) {
+    bindings.push({
+      binding: blockInfo.location,
+      visibility: (blockInfo.vertex ? 0x1 : 0) & (blockInfo.fragment ? 0x2 : 0),
+      buffer: {
+        type: 'uniform',
+        // minBindingSize: blockInfo.size
+      }
+    })
+  }
+
+  // Sampler uniforms
+  for (const uniformInfo of config.uniforms) {
+    let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[uniformInfo.type];
+    if (sampler) {
+      const [viewDimension, sampleType] = sampler;
+      bindings.push({
+        binding: uniformInfo.location,
+        visibility: 0, // Not available in WebGL on individual uniforms?
+        texture: {
+          viewDimension,
+          sampleType
+        }
+      });
+    }
+  }
+}
+
+// HELPERS
+
+function parseUniformName(name) {
+  // Shortcut to avoid redundant or bad matches
+  if (name[name.length - 1] !== ']'){
+    return {
+      name,
+      length: 1,
+      isArray: false
+    };
+  }
+
+  // if array name then clean the array brackets
+  const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
+  const matches = name.match(UNIFORM_NAME_REGEXP);
+  if (!matches || matches.length < 2) {
+    throw new Error(`Failed to parse GLSL uniform name ${name}`);
+  }
+
+  return {
+    name: matches[1],
+    length: matches[2] || 1,
+    isArray: Boolean(matches[2])
+  };
+}
+
+// Extract additional attribute metadata from shader names (based on attribute naming conventions)
+function inferProperties(accessor, location, name) {
+  if (/instance/i.test(name)) {
+    // Any attribute containing the word "instance" will be assumed to be instanced
+    accessor.divisor = 1;
+  }
+}

package/src/helpers/program-bindings.ts

@@ -0,0 +1,46 @@
+import {Accessor} from '../types/accessor';
+
+/** Describes an attribute binding for a program */
+export type AttributeBinding = {
+  location: number;
+  name: string;
+  accessor: Accessor;
+}
+
+/** Describes a varying binding for a program */
+export type VaryingBinding = {
+  location: number;
+  name: string;
+  accessor: Accessor;
+}
+
+/** Describes a uniform block binding for a program */
+export type UniformBlockBinding = {
+  location: number;
+  name: string;
+  byteLength: number;
+  vertex: boolean;
+  fragment: boolean;
+  uniformCount: number;
+  uniformIndices: number[];
+}
+
+/** Describes a uniform (sampler etc) binding for a program */
+export type UniformBinding = {
+  location: number;
+  name: string;
+  size: number;
+  type: number;
+  isArray: boolean;
+}
+
+/**
+ * Holds metadata describing attribute configurations for a program's shaders
+ */
+export type ProgramBindings = {
+  readonly attributes: AttributeBinding[];
+  readonly varyings: VaryingBinding[];
+  readonly uniformBlocks: UniformBlockBinding[];
+  // Note - samplers are always in unform bindings, even if uniform blocks are used
+  readonly uniforms: UniformBinding[];
+}

package/src/index.ts

@@ -0,0 +1,144 @@
+// luma.gl Base WebGL wrapper library
+// Provides simple class/function wrappers around the low level webgl objects
+// These classes are intentionally close to the WebGL API
+// but make it easier to use.
+// Higher level abstractions can be built on these classes
+
+// Initialize any global state
+import './init';
+
+// export type {WebGLDeviceProps, WebGLDeviceInfo, WebGPUDeviceLimits} from './lib/webgl-device';
+export type {WebGLDeviceProps} from './adapter/webgl-device';
+export {default as WebGLDevice, getWebGLDevice} from './adapter/webgl-device';
+
+// UTILS
+export {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';
+
+// WebGL Functions
+export {cloneTextureFrom} from './webgl-utils/texture-utils';
+export {getKeyValue, getKey} from './webgl-utils/constants-to-keys';
+
+// WebGL Helper Classes
+export {default as Accessor} from './classes/accessor';
+
+// WebGL1 classes
+export type {BufferProps} from '@luma.gl/api';
+export {default as Buffer} from './classes/webgl-buffer';
+export type {Texture2DProps} from './classes/texture-2d';
+export {default as Texture2D} from './classes/texture-2d';
+export type {TextureCubeProps} from './classes/texture-cube';
+export {default as TextureCube} from './classes/texture-cube';
+
+export type {ProgramProps} from './classes/program';
+export {default as Program} from './classes/program';
+export type {FramebufferProps} from './classes/framebuffer';
+export {default as Framebuffer} from './classes/framebuffer';
+export type {RenderbufferProps} from './classes/renderbuffer';
+export {default as Renderbuffer} from './classes/renderbuffer';
+
+// Classic luma.gl classes (For backwards compatibility)
+export type {ShaderProps} from './classes/shader';
+export {Shader, VertexShader, FragmentShader} from './classes/shader';
+
+export {clear, clearBuffer} from './classes/clear';
+
+// Copy and Blit
+export {
+  readPixelsToArray,
+  readPixelsToBuffer,
+  copyToDataUrl,
+  copyToImage,
+  copyToTexture,
+  blit
+} from './classes/copy-and-blit';
+
+// WebGL2 classes & Extensions
+export type {QueryProps} from './classes/query';
+export {default as Query} from './classes/query';
+export type {Texture3DProps} from './classes/texture-3d';
+export {default as Texture3D} from './classes/texture-3d';
+export type {TransformFeedbackProps} from './classes/transform-feedback';
+export {default as TransformFeedback} from './classes/transform-feedback';
+export type {VertexArrayObjectProps} from './classes/vertex-array-object';
+export {default as VertexArrayObject} from './classes/vertex-array-object';
+export type {VertexArrayProps} from './classes/vertex-array';
+export {default as VertexArray} from './classes/vertex-array';
+export {default as UniformBufferLayout} from './classes/uniform-buffer-layout';
+
+export {setDeviceParameters} from './adapter/converters/set-device-parameters';
+
+// experimental WebGL exports
+
+// UTILS
+export {
+  isWebGL,
+  isWebGL2,
+  getWebGL2Context,
+  assertWebGLContext,
+  assertWebGL2Context
+} from './context/context/webgl-checks';
+
+// Device ratio
+export {cssToDeviceRatio, cssToDevicePixels} from './context/context/device-pixels';
+
+// Unified parameter API
+
+export type {GLParameters} from './context/parameters/webgl-parameters';
+export {
+  getParameters,
+  setParameters,
+  resetParameters
+} from './context/parameters/unified-parameter-api';
+
+export {
+  withParameters
+} from './context/state-tracker/with-parameters';
+
+// State tracking
+export {
+  trackContextState,
+  pushContextState,
+  popContextState
+} from './context/state-tracker/track-context-state';
+
+// Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)
+export {polyfillContext} from './context/polyfill/polyfill-context';
+
+// INTERNAL
+export {parseUniformName, getUniformSetter} from './classes/uniforms';
+export {getDebugTableForUniforms} from './debug/debug-uniforms';
+export {getDebugTableForVertexArray} from './debug/debug-vertex-array';
+export {getDebugTableForProgramConfiguration} from './debug/debug-program-configuration';
+
+// HELPERS - EXPERIMENTAL
+export {getProgramBindings} from './helpers/get-program-bindings';
+
+// DEPRECATED
+
+// Deprecated re-exports
+export {lumaStats} from './init';
+export {log, assert, uid, isObjectEmpty} from '@luma.gl/api';
+export {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';
+
+// GLTOOLS
+export type {GLContextOptions} from './_deprecated/context-api';
+export {
+  createGLContext,
+  instrumentGLContext,
+  resizeGLContext,
+  hasFeature,
+  hasFeatures,
+  getFeatures,
+  getContextInfo,
+  getGLContextInfo,
+  getContextLimits,
+  getContextDebugInfo
+} from './_deprecated/context-api';
+
+// Features
+export {FEATURES} from './_deprecated/features';
+
+// REMOVED in v8.7
+// getShaderInfo,
+// getShaderName
+// getShaderVersion

package/src/{init.js → init.ts}

@@ -1,10 +1,10 @@
-import {log} from '@luma.gl/gltools';
-import {Stats} from 'probe.gl';
-import {isBrowser, global} from 'probe.gl/env';
+import {log} from '@luma.gl/api';
+import {isBrowser} from '@probe.gl/env';
+import {luma, lumaStats} from '@luma.gl/api';
+import WebGLDevice from './adapter/webgl-device';
 
 // Version detection using babel plugin
-/* global __VERSION__ */
-// @ts-ignore
+// @ts-expect-error
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';
 
 const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
@@ -12,32 +12,18 @@ const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
 // 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
 // luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
 
-class StatsManager {
-  constructor() {
-    this.stats = new Map();
-  }
-
-  get(name) {
-    if (!this.stats.has(name)) {
-      this.stats.set(name, new Stats({id: name}));
-    }
-
-    return this.stats.get(name);
-  }
+if (globalThis.luma && globalThis.luma.VERSION !== VERSION) {
+  throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION}`);
 }
 
-const lumaStats = new StatsManager();
-
-if (global.luma && global.luma.VERSION !== VERSION) {
-  throw new Error(`luma.gl - multiple VERSIONs detected: ${global.luma.VERSION} vs ${VERSION}`);
-}
+if (!globalThis.luma) {
+  luma.registerDevices([WebGLDevice]);
 
-if (!global.luma) {
   if (isBrowser()) {
     log.log(1, `luma.gl ${VERSION} - ${STARTUP_MESSAGE}`)();
   }
 
-  global.luma = global.luma || {
+  globalThis.luma = globalThis.luma || {
     VERSION,
     version: VERSION,
     log,
@@ -59,4 +45,4 @@ if (!global.luma) {
 }
 
 export {lumaStats};
-export default global.luma;
+export default globalThis.luma;

package/src/types/accessor.d.ts

@@ -0,0 +1,29 @@
+// ACCESSORS
+
+/**
+ * Attribute descriptor object
+ */
+export type Accessor = {
+  format?: string;
+  offset?: number;
+  location?: number;
+
+  // can now be described with single WebGPU-style `format` string
+  type?: number;
+  size?: number;
+  normalized?: boolean;
+  integer?: boolean;
+
+  // deprecated - now shared between accessors in the surrounding BufferAccessor object
+  stride?: number;
+  divisor?: number;
+};
+
+/**
+ * List of attribute descriptors for one interleaved buffer
+ */
+export type BufferAccessors = {
+  stride?: number;
+  stepMode?: 'vertex' | 'instance';
+  attributes: Accessor[];
+}

package/src/{types.d.ts → types.ts}

@@ -5,4 +5,4 @@ export type AccessorObject = {
   divisor?: number;
   offset?: number;
   stride?: number;
-};
+};

package/src/webgl-utils/{attribute-utils.js → attribute-utils.ts}

@@ -1,5 +1,4 @@
-/* eslint-disable camelcase */
-import {assert} from '../utils/assert';
+import {assert} from '@luma.gl/api';
 
 const GL_BYTE = 0x1400;
 const GL_UNSIGNED_BYTE = 0x1401;

package/src/webgl-utils/{constants-to-keys.js → constants-to-keys.ts}

@@ -1,4 +1,4 @@
-import {assert} from '../utils/assert';
+import {assert} from '@luma.gl/api';
 
 // Resolve a WebGL enumeration name (returns itself if already a number)
 export function getKeyValue(gl, name) {

package/src/webgl-utils/{format-utils.js → format-utils.ts}

@@ -1,5 +1,5 @@
+import {assert} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {assert} from '../utils/assert';
 
 // Returns number of components in a specific readPixels WebGL format
 export function glFormatToComponents(format) {

package/src/webgl-utils/index.ts

@@ -0,0 +1,12 @@
+export {requestAnimationFrame, cancelAnimationFrame} from './request-animation-frame';
+
+export {
+  getGLTypeFromTypedArray,
+  getTypedArrayFromGLType,
+  flipRows,
+  scalePixels
+} from './typed-array-utils';
+
+export {getKeyValue, getKey, getKeyType} from './constants-to-keys';
+
+export {cloneTextureFrom} from './texture-utils';

package/src/webgl-utils/parse-shader-compiler-log.ts

@@ -0,0 +1,48 @@
+// luma.gl, MIT license
+import type {CompilerMessage} from '@luma.gl/shadertools';
+
+const MESSAGE_TYPES = ['warning', 'error', 'info'];
+
+/**
+ * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.
+ * This follows documented WebGL conventions for compilation logs.
+ * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)
+ */
+export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessage[] {
+  // Parse the error - note: browser and driver dependent
+  const lines = errLog.split(/\r?\n/);
+
+  const messages: CompilerMessage[] = [];
+
+  for (const line of lines) {
+    if (line.length <= 1) {
+      continue;
+    }
+
+    const segments: string[] = line.split(':');
+    const [messageType, linePosition, lineNumber, ...rest] = segments;
+
+    let lineNum = parseInt(lineNumber, 10);
+    if (isNaN(lineNum)) {
+      lineNum = 0;
+    }
+
+    let linePos = parseInt(linePosition, 10);
+    if (isNaN(linePos)) {
+      linePos = 0;
+    }
+
+    // Ensure supported type
+    const lowerCaseType = messageType.toLowerCase();
+    const type = (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as 'warning' | 'error' | 'info';
+
+    messages.push({
+      message: rest.join(':').trim(),
+      type,
+      lineNum,
+      linePos // TODO
+    })
+  }
+
+  return messages;
+}