@tldraw/tlschema 4.2.2 → 4.2.3

package/src/styles/TLColorStyle.test.ts

@@ -0,0 +1,439 @@
+import { describe, expect, it, test } from 'vitest'
+import {
+	defaultColorNames,
+	DefaultColorStyle,
+	DefaultColorThemePalette,
+	DefaultLabelColorStyle,
+	getColorValue,
+	getDefaultColorTheme,
+	isDefaultThemeColor,
+	TLDefaultColorStyle,
+	TLDefaultColorThemeColor,
+} from './TLColorStyle'
+
+describe('TLColorStyle', () => {
+	describe('defaultColorNames', () => {
+		it('should contain expected default colors', () => {
+			expect(defaultColorNames).toEqual([
+				'black',
+				'grey',
+				'light-violet',
+				'violet',
+				'blue',
+				'light-blue',
+				'yellow',
+				'orange',
+				'green',
+				'light-green',
+				'light-red',
+				'red',
+				'white',
+			])
+		})
+	})
+
+	describe('DefaultColorThemePalette', () => {
+		it('should contain all default colors for both themes', () => {
+			const lightTheme = DefaultColorThemePalette.lightMode
+			const darkTheme = DefaultColorThemePalette.darkMode
+
+			defaultColorNames.forEach((colorName) => {
+				expect(lightTheme).toHaveProperty(colorName)
+				expect(darkTheme).toHaveProperty(colorName)
+			})
+		})
+	})
+
+	describe('getDefaultColorTheme', () => {
+		it('should return light theme when isDarkMode is false', () => {
+			const result = getDefaultColorTheme({ isDarkMode: false })
+			expect(result).toBe(DefaultColorThemePalette.lightMode)
+		})
+
+		it('should return dark theme when isDarkMode is true', () => {
+			const result = getDefaultColorTheme({ isDarkMode: true })
+			expect(result).toBe(DefaultColorThemePalette.darkMode)
+		})
+	})
+
+	describe('DefaultColorStyle', () => {
+		it('should validate all default color names', () => {
+			defaultColorNames.forEach((color) => {
+				expect(() => DefaultColorStyle.validate(color)).not.toThrow()
+				expect(DefaultColorStyle.validate(color)).toBe(color)
+			})
+		})
+
+		it('should reject invalid color names', () => {
+			const invalidColors = ['invalid', 'pink', 'purple', 'cyan', '']
+
+			invalidColors.forEach((color) => {
+				expect(() => DefaultColorStyle.validate(color)).toThrow()
+			})
+		})
+	})
+
+	describe('DefaultLabelColorStyle', () => {
+		it('should be a StyleProp with correct configuration', () => {
+			expect(DefaultLabelColorStyle.id).toBe('tldraw:labelColor')
+			expect(DefaultLabelColorStyle.defaultValue).toBe('black')
+		})
+
+		it('should validate all default color names', () => {
+			defaultColorNames.forEach((color) => {
+				expect(() => DefaultLabelColorStyle.validate(color)).not.toThrow()
+				expect(DefaultLabelColorStyle.validate(color)).toBe(color)
+			})
+		})
+
+		it('should reject invalid color names', () => {
+			const invalidColors = ['invalid', 'pink', 'purple', 'cyan', '']
+
+			invalidColors.forEach((color) => {
+				expect(() => DefaultLabelColorStyle.validate(color)).toThrow()
+			})
+		})
+
+		it('should have values property with all default colors', () => {
+			expect(DefaultLabelColorStyle.values).toEqual(defaultColorNames)
+		})
+
+		it('should be separate from DefaultColorStyle', () => {
+			expect(DefaultColorStyle.id).not.toBe(DefaultLabelColorStyle.id)
+			expect(DefaultColorStyle).not.toBe(DefaultLabelColorStyle)
+		})
+
+		it('should allow different default values from DefaultColorStyle', () => {
+			const originalColorDefault = DefaultColorStyle.defaultValue
+			const originalLabelDefault = DefaultLabelColorStyle.defaultValue
+
+			DefaultColorStyle.setDefaultValue('red')
+			DefaultLabelColorStyle.setDefaultValue('blue')
+
+			expect(DefaultColorStyle.defaultValue).toBe('red')
+			expect(DefaultLabelColorStyle.defaultValue).toBe('blue')
+			expect(DefaultColorStyle.defaultValue).not.toBe(DefaultLabelColorStyle.defaultValue)
+
+			// Restore originals
+			DefaultColorStyle.setDefaultValue(originalColorDefault)
+			DefaultLabelColorStyle.setDefaultValue(originalLabelDefault)
+		})
+	})
+
+	describe('isDefaultThemeColor', () => {
+		it('should return true for all default color names', () => {
+			defaultColorNames.forEach((color) => {
+				expect(isDefaultThemeColor(color)).toBe(true)
+			})
+		})
+
+		it('should return false for invalid color names', () => {
+			const invalidColors = ['invalid', 'pink', 'purple', 'cyan', '', 'custom-color']
+
+			invalidColors.forEach((color) => {
+				expect(isDefaultThemeColor(color as TLDefaultColorStyle)).toBe(false)
+			})
+		})
+
+		it('should return false for hex colors', () => {
+			const hexColors = ['#ff0000', '#00ff00', '#0000ff', '#ffffff', '#000000']
+
+			hexColors.forEach((color) => {
+				expect(isDefaultThemeColor(color as TLDefaultColorStyle)).toBe(false)
+			})
+		})
+
+		it('should return false for CSS color names not in defaults', () => {
+			// Use CSS color names that are NOT in the default color list
+			const cssColors = ['aqua', 'fuchsia', 'lime', 'navy', 'silver']
+
+			cssColors.forEach((color) => {
+				expect(isDefaultThemeColor(color as TLDefaultColorStyle)).toBe(false)
+			})
+		})
+
+		it('should handle edge cases', () => {
+			expect(isDefaultThemeColor(null as any)).toBe(false)
+			expect(isDefaultThemeColor(undefined as any)).toBe(false)
+			expect(isDefaultThemeColor(123 as any)).toBe(false)
+			expect(isDefaultThemeColor({} as any)).toBe(false)
+		})
+
+		it('should be case sensitive', () => {
+			expect(isDefaultThemeColor('Black' as TLDefaultColorStyle)).toBe(false)
+			expect(isDefaultThemeColor('RED' as TLDefaultColorStyle)).toBe(false)
+			expect(isDefaultThemeColor('Blue' as TLDefaultColorStyle)).toBe(false)
+		})
+
+		it('should work as a type guard', () => {
+			const color: TLDefaultColorStyle = 'red'
+
+			if (isDefaultThemeColor(color)) {
+				// TypeScript should narrow the type here
+				expect(defaultColorNames.includes(color)).toBe(true)
+			}
+		})
+	})
+
+	describe('getColorValue', () => {
+		const lightTheme = DefaultColorThemePalette.lightMode
+		const darkTheme = DefaultColorThemePalette.darkMode
+
+		it('should return correct color values for default colors', () => {
+			expect(getColorValue(lightTheme, 'red', 'solid')).toBe('#e03131')
+			expect(getColorValue(lightTheme, 'blue', 'fill')).toBe('#4465e9')
+			expect(getColorValue(lightTheme, 'black', 'solid')).toBe('#1d1d1d')
+		})
+
+		it('should work with different variants', () => {
+			const variants: (keyof TLDefaultColorThemeColor)[] = [
+				'solid',
+				'semi',
+				'pattern',
+				'fill',
+				'frameHeadingStroke',
+				'frameHeadingFill',
+				'frameStroke',
+				'frameFill',
+				'frameText',
+				'noteFill',
+				'noteText',
+				'highlightSrgb',
+				'highlightP3',
+			]
+
+			variants.forEach((variant) => {
+				const result = getColorValue(lightTheme, 'red', variant)
+				expect(typeof result).toBe('string')
+				expect(result.length).toBeGreaterThan(0)
+				expect(result).toBe(lightTheme.red[variant])
+			})
+		})
+
+		it('should return different values for light and dark themes', () => {
+			// Use colors/variants that actually differ between themes
+			expect(getColorValue(lightTheme, 'black', 'solid')).not.toBe(
+				getColorValue(darkTheme, 'black', 'solid')
+			)
+			expect(getColorValue(lightTheme, 'white', 'solid')).not.toBe(
+				getColorValue(darkTheme, 'white', 'solid')
+			)
+		})
+
+		it('should pass through non-default colors unchanged', () => {
+			const customColors = ['#ff0000', '#00ff00', '#0000ff', 'custom-color', 'rgb(255, 0, 0)']
+
+			customColors.forEach((color) => {
+				expect(getColorValue(lightTheme, color as TLDefaultColorStyle, 'solid')).toBe(color)
+				expect(getColorValue(darkTheme, color as TLDefaultColorStyle, 'fill')).toBe(color)
+			})
+		})
+
+		it('should work with all default colors', () => {
+			defaultColorNames.forEach((colorName) => {
+				const lightResult = getColorValue(lightTheme, colorName, 'solid')
+				const darkResult = getColorValue(darkTheme, colorName, 'solid')
+
+				expect(typeof lightResult).toBe('string')
+				expect(typeof darkResult).toBe('string')
+				expect(lightResult).toBe(lightTheme[colorName].solid)
+				expect(darkResult).toBe(darkTheme[colorName].solid)
+			})
+		})
+
+		it('should handle edge cases gracefully', () => {
+			// Test with empty string
+			expect(getColorValue(lightTheme, '' as TLDefaultColorStyle, 'solid')).toBe('')
+
+			// Test with null/undefined (they should pass through)
+			expect(getColorValue(lightTheme, null as any, 'solid')).toBe(null)
+			expect(getColorValue(lightTheme, undefined as any, 'solid')).toBe(undefined)
+		})
+
+		it('should work consistently across all variants for a color', () => {
+			const color = 'blue'
+			const variants: (keyof TLDefaultColorThemeColor)[] = [
+				'solid',
+				'semi',
+				'pattern',
+				'fill',
+				'frameHeadingStroke',
+				'frameHeadingFill',
+				'frameStroke',
+				'frameFill',
+				'frameText',
+				'noteFill',
+				'noteText',
+				'highlightSrgb',
+				'highlightP3',
+			]
+
+			variants.forEach((variant) => {
+				const lightResult = getColorValue(lightTheme, color, variant)
+				const darkResult = getColorValue(darkTheme, color, variant)
+
+				expect(lightResult).toBe(lightTheme[color][variant])
+				expect(darkResult).toBe(darkTheme[color][variant])
+			})
+		})
+
+		it('should maintain consistency with isDefaultThemeColor', () => {
+			const testColors = [...defaultColorNames, '#ff0000', 'custom', 'invalid']
+
+			testColors.forEach((color) => {
+				const isDefault = isDefaultThemeColor(color as TLDefaultColorStyle)
+				const result = getColorValue(lightTheme, color as TLDefaultColorStyle, 'solid')
+
+				if (isDefault) {
+					// Should return the theme color value
+					expect(result).toBe(
+						(lightTheme[color as keyof typeof lightTheme] as TLDefaultColorThemeColor).solid
+					)
+				} else {
+					// Should pass through unchanged
+					expect(result).toBe(color)
+				}
+			})
+		})
+	})
+
+	describe('type safety and integration', () => {
+		it('should have proper TypeScript types', () => {
+			// Test that TLDefaultColorStyle is properly typed
+			const validColor: TLDefaultColorStyle = 'red'
+			expect(DefaultColorStyle.validate(validColor)).toBe('red')
+		})
+
+		it('should work with both color style props', () => {
+			const colorValue: TLDefaultColorStyle = 'blue'
+			const labelColorValue: TLDefaultColorStyle = 'white'
+
+			expect(DefaultColorStyle.validate(colorValue)).toBe('blue')
+			expect(DefaultLabelColorStyle.validate(labelColorValue)).toBe('white')
+		})
+
+		it('should integrate properly with theme system', () => {
+			const theme = getDefaultColorTheme({ isDarkMode: false })
+			const color: TLDefaultColorStyle = 'red'
+
+			if (isDefaultThemeColor(color)) {
+				const colorValue = getColorValue(theme, color, 'solid')
+				expect(typeof colorValue).toBe('string')
+				expect(colorValue).toBe(theme.red.solid)
+			}
+		})
+
+		it('should maintain consistent behavior across all exports', () => {
+			// Test that all parts work together correctly
+			const theme = getDefaultColorTheme({ isDarkMode: false })
+
+			defaultColorNames.forEach((colorName) => {
+				// Should validate in both style props
+				expect(DefaultColorStyle.validate(colorName)).toBe(colorName)
+				expect(DefaultLabelColorStyle.validate(colorName)).toBe(colorName)
+
+				// Should be recognized as default theme color
+				expect(isDefaultThemeColor(colorName)).toBe(true)
+
+				// Should resolve to theme color value
+				const colorValue = getColorValue(theme, colorName, 'solid')
+				expect(colorValue).toBe(theme[colorName].solid)
+			})
+		})
+	})
+
+	describe('error handling and edge cases', () => {
+		it('should handle malformed theme objects gracefully', () => {
+			// Create a partial theme for testing edge cases
+			const partialTheme = {
+				...DefaultColorThemePalette.lightMode,
+				red: {
+					...DefaultColorThemePalette.lightMode.red,
+					solid: undefined,
+				} as any,
+			}
+
+			// getColorValue should still work but return undefined for this case
+			expect(getColorValue(partialTheme, 'red', 'solid')).toBe(undefined)
+		})
+
+		it('should handle very large color names', () => {
+			const longColorName = 'a'.repeat(1000)
+			expect(isDefaultThemeColor(longColorName as TLDefaultColorStyle)).toBe(false)
+			expect(
+				getColorValue(
+					DefaultColorThemePalette.lightMode,
+					longColorName as TLDefaultColorStyle,
+					'solid'
+				)
+			).toBe(longColorName)
+		})
+
+		it('should handle special characters in color values', () => {
+			const specialColors = ['color-with-dashes', 'color_with_underscores', 'color.with.dots']
+
+			specialColors.forEach((color) => {
+				expect(isDefaultThemeColor(color as TLDefaultColorStyle)).toBe(false)
+				expect(
+					getColorValue(DefaultColorThemePalette.lightMode, color as TLDefaultColorStyle, 'solid')
+				).toBe(color)
+			})
+		})
+
+		test('should maintain immutability of exported objects', () => {
+			const originalLightTheme = DefaultColorThemePalette.lightMode
+			const originalDarkTheme = DefaultColorThemePalette.darkMode
+			const originalColorNames = defaultColorNames
+
+			// These should be the same references
+			expect(getDefaultColorTheme({ isDarkMode: false })).toBe(originalLightTheme)
+			expect(getDefaultColorTheme({ isDarkMode: true })).toBe(originalDarkTheme)
+
+			// Arrays should maintain their values
+			expect(defaultColorNames).toEqual(originalColorNames)
+			expect(DefaultColorStyle.values).toEqual(originalColorNames)
+		})
+	})
+
+	describe('performance considerations', () => {
+		it('should validate colors efficiently', () => {
+			const start = performance.now()
+
+			for (let i = 0; i < 1000; i++) {
+				defaultColorNames.forEach((color) => {
+					DefaultColorStyle.validate(color)
+					isDefaultThemeColor(color)
+				})
+			}
+
+			const end = performance.now()
+			expect(end - start).toBeLessThan(100) // Should be fast
+		})
+
+		it('should resolve color values efficiently', () => {
+			const theme = DefaultColorThemePalette.lightMode
+			const start = performance.now()
+
+			for (let i = 0; i < 1000; i++) {
+				defaultColorNames.forEach((color) => {
+					getColorValue(theme, color, 'solid')
+					getColorValue(theme, color, 'fill')
+				})
+			}
+
+			const end = performance.now()
+			expect(end - start).toBeLessThan(50) // Should be very fast
+		})
+
+		it('should handle theme switching efficiently', () => {
+			const start = performance.now()
+
+			for (let i = 0; i < 1000; i++) {
+				getDefaultColorTheme({ isDarkMode: i % 2 === 0 })
+			}
+
+			const end = performance.now()
+			expect(end - start).toBeLessThan(10) // Should be extremely fast (just returns references)
+		})
+	})
+})

package/dist-cjs/misc/b64Vecs.js

@@ -1,224 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var b64Vecs_exports = {};
-__export(b64Vecs_exports, {
-  b64Vecs: () => b64Vecs
-});
-module.exports = __toCommonJS(b64Vecs_exports);
-const POINT_B64_LENGTH = 8;
-const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const B64_LOOKUP = new Uint8Array(128);
-for (let i = 0; i < 64; i++) {
-  B64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
-}
-const POW2 = new Float64Array(31);
-for (let i = 0; i < 31; i++) {
-  POW2[i] = Math.pow(2, i - 15);
-}
-const POW2_SUBNORMAL = Math.pow(2, -14) / 1024;
-const MANTISSA = new Float64Array(1024);
-for (let i = 0; i < 1024; i++) {
-  MANTISSA[i] = 1 + i / 1024;
-}
-function uint16ArrayToBase64(uint16Array) {
-  const uint8Array = new Uint8Array(
-    uint16Array.buffer,
-    uint16Array.byteOffset,
-    uint16Array.byteLength
-  );
-  let result = "";
-  for (let i = 0; i < uint8Array.length; i += 3) {
-    const byte1 = uint8Array[i];
-    const byte2 = uint8Array[i + 1];
-    const byte3 = uint8Array[i + 2];
-    const bitmap = byte1 << 16 | byte2 << 8 | byte3;
-    result += BASE64_CHARS[bitmap >> 18 & 63] + BASE64_CHARS[bitmap >> 12 & 63] + BASE64_CHARS[bitmap >> 6 & 63] + BASE64_CHARS[bitmap & 63];
-  }
-  return result;
-}
-function base64ToUint16Array(base64) {
-  const numBytes = Math.floor(base64.length * 3 / 4);
-  const bytes = new Uint8Array(numBytes);
-  let byteIndex = 0;
-  for (let i = 0; i < base64.length; i += 4) {
-    const c0 = B64_LOOKUP[base64.charCodeAt(i)];
-    const c1 = B64_LOOKUP[base64.charCodeAt(i + 1)];
-    const c2 = B64_LOOKUP[base64.charCodeAt(i + 2)];
-    const c3 = B64_LOOKUP[base64.charCodeAt(i + 3)];
-    const bitmap = c0 << 18 | c1 << 12 | c2 << 6 | c3;
-    bytes[byteIndex++] = bitmap >> 16 & 255;
-    bytes[byteIndex++] = bitmap >> 8 & 255;
-    bytes[byteIndex++] = bitmap & 255;
-  }
-  return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
-}
-function float16BitsToNumber(bits) {
-  const sign = bits >> 15;
-  const exp = bits >> 10 & 31;
-  const frac = bits & 1023;
-  if (exp === 0) {
-    return sign ? -frac * POW2_SUBNORMAL : frac * POW2_SUBNORMAL;
-  }
-  if (exp === 31) {
-    return frac ? NaN : sign ? -Infinity : Infinity;
-  }
-  const magnitude = POW2[exp] * MANTISSA[frac];
-  return sign ? -magnitude : magnitude;
-}
-function numberToFloat16Bits(value) {
-  if (value === 0) return Object.is(value, -0) ? 32768 : 0;
-  if (!Number.isFinite(value)) {
-    if (Number.isNaN(value)) return 32256;
-    return value > 0 ? 31744 : 64512;
-  }
-  const sign = value < 0 ? 1 : 0;
-  value = Math.abs(value);
-  const exp = Math.floor(Math.log2(value));
-  let expBiased = exp + 15;
-  if (expBiased >= 31) {
-    return sign << 15 | 31744;
-  }
-  if (expBiased <= 0) {
-    const frac2 = Math.round(value * Math.pow(2, 14) * 1024);
-    return sign << 15 | frac2 & 1023;
-  }
-  const mantissa = value / Math.pow(2, exp) - 1;
-  let frac = Math.round(mantissa * 1024);
-  if (frac >= 1024) {
-    frac = 0;
-    expBiased++;
-    if (expBiased >= 31) {
-      return sign << 15 | 31744;
-    }
-  }
-  return sign << 15 | expBiased << 10 | frac;
-}
-class b64Vecs {
-  /**
-   * Encode a single point (x, y, z) to 8 base64 characters.
-   * Each coordinate is encoded as a Float16 value, resulting in 6 bytes total.
-   *
-   * @param x - The x coordinate
-   * @param y - The y coordinate
-   * @param z - The z coordinate
-   * @returns An 8-character base64 string representing the point
-   */
-  static encodePoint(x, y, z) {
-    const xBits = numberToFloat16Bits(x);
-    const yBits = numberToFloat16Bits(y);
-    const zBits = numberToFloat16Bits(z);
-    const b0 = xBits & 255;
-    const b1 = xBits >> 8 & 255;
-    const b2 = yBits & 255;
-    const b3 = yBits >> 8 & 255;
-    const b4 = zBits & 255;
-    const b5 = zBits >> 8 & 255;
-    const bitmap1 = b0 << 16 | b1 << 8 | b2;
-    const bitmap2 = b3 << 16 | b4 << 8 | b5;
-    return BASE64_CHARS[bitmap1 >> 18 & 63] + BASE64_CHARS[bitmap1 >> 12 & 63] + BASE64_CHARS[bitmap1 >> 6 & 63] + BASE64_CHARS[bitmap1 & 63] + BASE64_CHARS[bitmap2 >> 18 & 63] + BASE64_CHARS[bitmap2 >> 12 & 63] + BASE64_CHARS[bitmap2 >> 6 & 63] + BASE64_CHARS[bitmap2 & 63];
-  }
-  /**
-   * Convert an array of VecModels to a base64 string for compact storage.
-   * Uses Float16 encoding for each coordinate (x, y, z). If a point's z value is
-   * undefined, it defaults to 0.5.
-   *
-   * @param points - An array of VecModel objects to encode
-   * @returns A base64-encoded string containing all points
-   */
-  static encodePoints(points) {
-    const uint16s = new Uint16Array(points.length * 3);
-    for (let i = 0; i < points.length; i++) {
-      const p = points[i];
-      uint16s[i * 3] = numberToFloat16Bits(p.x);
-      uint16s[i * 3 + 1] = numberToFloat16Bits(p.y);
-      uint16s[i * 3 + 2] = numberToFloat16Bits(p.z ?? 0.5);
-    }
-    return uint16ArrayToBase64(uint16s);
-  }
-  /**
-   * Convert a base64 string back to an array of VecModels.
-   * Decodes Float16-encoded coordinates (x, y, z) from the base64 string.
-   *
-   * @param base64 - The base64-encoded string containing point data
-   * @returns An array of VecModel objects decoded from the string
-   */
-  static decodePoints(base64) {
-    const uint16s = base64ToUint16Array(base64);
-    const result = [];
-    for (let i = 0; i < uint16s.length; i += 3) {
-      result.push({
-        x: float16BitsToNumber(uint16s[i]),
-        y: float16BitsToNumber(uint16s[i + 1]),
-        z: float16BitsToNumber(uint16s[i + 2])
-      });
-    }
-    return result;
-  }
-  /**
-   * Decode a single point (8 base64 chars) starting at the given offset.
-   * Each point is encoded as 3 Float16 values (x, y, z) in 8 base64 characters.
-   *
-   * @param b64Points - The base64-encoded string containing point data
-   * @param charOffset - The character offset where the point starts (must be a multiple of 8)
-   * @returns A VecModel object with x, y, and z coordinates
-   * @internal
-   */
-  static decodePointAt(b64Points, charOffset) {
-    const c0 = B64_LOOKUP[b64Points.charCodeAt(charOffset)];
-    const c1 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 1)];
-    const c2 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 2)];
-    const c3 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 3)];
-    const c4 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 4)];
-    const c5 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 5)];
-    const c6 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 6)];
-    const c7 = B64_LOOKUP[b64Points.charCodeAt(charOffset + 7)];
-    const bitmap1 = c0 << 18 | c1 << 12 | c2 << 6 | c3;
-    const bitmap2 = c4 << 18 | c5 << 12 | c6 << 6 | c7;
-    const xBits = bitmap1 >> 16 & 255 | bitmap1 & 65280;
-    const yBits = bitmap1 & 255 | bitmap2 >> 8 & 65280;
-    const zBits = bitmap2 >> 8 & 255 | bitmap2 << 8 & 65280;
-    return {
-      x: float16BitsToNumber(xBits),
-      y: float16BitsToNumber(yBits),
-      z: float16BitsToNumber(zBits)
-    };
-  }
-  /**
-   * Get the first point from a base64-encoded string of points.
-   *
-   * @param b64Points - The base64-encoded string containing point data
-   * @returns The first point as a VecModel, or null if the string is too short
-   * @public
-   */
-  static decodeFirstPoint(b64Points) {
-    if (b64Points.length < POINT_B64_LENGTH) return null;
-    return b64Vecs.decodePointAt(b64Points, 0);
-  }
-  /**
-   * Get the last point from a base64-encoded string of points.
-   *
-   * @param b64Points - The base64-encoded string containing point data
-   * @returns The last point as a VecModel, or null if the string is too short
-   */
-  static decodeLastPoint(b64Points) {
-    if (b64Points.length < POINT_B64_LENGTH) return null;
-    return b64Vecs.decodePointAt(b64Points, b64Points.length - POINT_B64_LENGTH);
-  }
-}
-//# sourceMappingURL=b64Vecs.js.map