goscript 0.1.0 → 0.1.2

package/gs/unicode/unicode.ts

@@ -1,3 +1,5 @@
+import type { Slice } from '@goscript/builtin/index.js'
+
 // Package unicode provides data and functions to test some properties of Unicode code points.
 
 // Constants
@@ -16,13 +18,27 @@ export const MaxCase = 3
 export const UpperLower = MaxRune + 1
 
 // Range16 represents a range of 16-bit Unicode code points
+type Range16Init = {
+  Lo?: number
+  Hi?: number
+  Stride?: number
+}
+
 export class Range16 {
   public Lo: number
   public Hi: number
   public Stride: number
 
-  constructor(lo: number, hi: number, stride: number) {
-    this.Lo = lo
+  constructor(init?: Range16Init)
+  constructor(lo: number, hi: number, stride: number)
+  constructor(loOrInit: number | Range16Init = 0, hi = 0, stride = 0) {
+    if (typeof loOrInit === 'object') {
+      this.Lo = loOrInit.Lo ?? 0
+      this.Hi = loOrInit.Hi ?? 0
+      this.Stride = loOrInit.Stride ?? 0
+      return
+    }
+    this.Lo = loOrInit
     this.Hi = hi
     this.Stride = stride
   }
@@ -33,13 +49,27 @@ export class Range16 {
 }
 
 // Range32 represents a range of 32-bit Unicode code points
+type Range32Init = {
+  Lo?: number
+  Hi?: number
+  Stride?: number
+}
+
 export class Range32 {
   public Lo: number
   public Hi: number
   public Stride: number
 
-  constructor(lo: number, hi: number, stride: number) {
-    this.Lo = lo
+  constructor(init?: Range32Init)
+  constructor(lo: number, hi: number, stride: number)
+  constructor(loOrInit: number | Range32Init = 0, hi = 0, stride = 0) {
+    if (typeof loOrInit === 'object') {
+      this.Lo = loOrInit.Lo ?? 0
+      this.Hi = loOrInit.Hi ?? 0
+      this.Stride = loOrInit.Stride ?? 0
+      return
+    }
+    this.Lo = loOrInit
     this.Hi = hi
     this.Stride = stride
   }
@@ -50,18 +80,32 @@ export class Range32 {
 }
 
 // RangeTable defines a set of Unicode code points by listing the ranges of code points within the set
+type RangeTableInit = {
+  R16?: Slice<Range16>
+  R32?: Slice<Range32>
+  LatinOffset?: number
+}
+
 export class RangeTable {
   public R16: Range16[]
   public R32: Range32[]
   public LatinOffset: number
 
+  constructor(init?: RangeTableInit)
+  constructor(r16?: Slice<Range16>, r32?: Slice<Range32>, latinOffset?: number)
   constructor(
-    r16: Range16[] = [],
-    r32: Range32[] = [],
-    latinOffset: number = 0,
+    r16OrInit: Slice<Range16> | RangeTableInit = [],
+    r32: Slice<Range32> = [],
+    latinOffset = 0,
   ) {
-    this.R16 = r16
-    this.R32 = r32
+    if (isRangeTableInit(r16OrInit)) {
+      this.R16 = sliceToArray(r16OrInit.R16)
+      this.R32 = sliceToArray(r16OrInit.R32)
+      this.LatinOffset = r16OrInit.LatinOffset ?? 0
+      return
+    }
+    this.R16 = sliceToArray(r16OrInit)
+    this.R32 = sliceToArray(r32)
     this.LatinOffset = latinOffset
   }
 
@@ -74,6 +118,23 @@ export class RangeTable {
   }
 }
 
+function isRangeTableInit(
+  value: Slice<Range16> | RangeTableInit,
+): value is RangeTableInit {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    ('R16' in value || 'R32' in value || 'LatinOffset' in value)
+  )
+}
+
+function sliceToArray<T>(value: Slice<T> | undefined): T[] {
+  if (value == null) {
+    return []
+  }
+  return Array.from(value as ArrayLike<T>)
+}
+
 // CaseRange represents a range of Unicode code points for case mapping
 export class CaseRange {
   public Lo: number
@@ -345,6 +406,48 @@ export const Categories = new Map<string, RangeTable>([
   ['Z', Space],
 ])
 
+export const CategoryAliases = new Map<string, string>([
+  ['C', 'C'],
+  ['Cc', 'Cc'],
+  ['cntrl', 'Cc'],
+  ['Cf', 'Cf'],
+  ['Co', 'Co'],
+  ['Cs', 'Cs'],
+  ['L', 'L'],
+  ['LC', 'LC'],
+  ['Ll', 'Ll'],
+  ['Lm', 'Lm'],
+  ['Lo', 'Lo'],
+  ['Lt', 'Lt'],
+  ['Lu', 'Lu'],
+  ['M', 'M'],
+  ['Mc', 'Mc'],
+  ['Me', 'Me'],
+  ['Mn', 'Mn'],
+  ['N', 'N'],
+  ['Nd', 'Nd'],
+  ['digit', 'Nd'],
+  ['Nl', 'Nl'],
+  ['No', 'No'],
+  ['P', 'P'],
+  ['Pc', 'Pc'],
+  ['Pd', 'Pd'],
+  ['Pe', 'Pe'],
+  ['Pf', 'Pf'],
+  ['Pi', 'Pi'],
+  ['Po', 'Po'],
+  ['Ps', 'Ps'],
+  ['S', 'S'],
+  ['Sc', 'Sc'],
+  ['Sk', 'Sk'],
+  ['Sm', 'Sm'],
+  ['So', 'So'],
+  ['Z', 'Z'],
+  ['Zl', 'Zl'],
+  ['Zp', 'Zp'],
+  ['Zs', 'Zs'],
+])
+
 // Scripts and Properties maps (simplified)
 export const Scripts = new Map<string, RangeTable>()
 export const Properties = new Map<string, RangeTable>()
@@ -370,6 +473,7 @@ export const Cc = new RangeTable(
   [],
 )
 export const Cf = new RangeTable([], [])
+export const Cn = new RangeTable([], [])
 export const Co = new RangeTable([], [])
 export const Cs = new RangeTable([new Range16(0xd800, 0xdfff, 1)], [])
 export const Lm = new RangeTable([], [])
@@ -416,3 +520,5 @@ export const So = new RangeTable([], [])
 export const Zl = new RangeTable([], [])
 export const Zp = new RangeTable([], [])
 export const Zs = new RangeTable([new Range16(0x0020, 0x0020, 1)], []) // space
+
+Categories.set('Cn', Cn)

package/gs/unicode/utf8/utf8.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { FullRune } from './utf8.js'
+
+describe('unicode/utf8 overrides', () => {
+  it('accepts GoScript byte slices in FullRune', () => {
+    expect(FullRune($.arrayToSlice<number>([0x61]))).toBe(true)
+    expect(FullRune($.goSlice([0xe2, 0x82, 0xac], 0, 2))).toBe(false)
+    expect(FullRune($.goSlice([0xe2, 0x82, 0xac], 0, 3))).toBe(true)
+  })
+})

package/gs/unicode/utf8/utf8.ts

@@ -26,19 +26,20 @@ export function AppendRune(p: $.Bytes, r: number): Uint8Array {
 }
 
 // DecodeLastRune unpacks the last UTF-8 encoding in p and returns the rune and its width in bytes.
-export function DecodeLastRune(p: Uint8Array): [number, number] {
-  if (p.length === 0) {
+export function DecodeLastRune(p: $.Bytes): [number, number] {
+  const bytes = $.bytesToUint8Array(p)
+  if (bytes.length === 0) {
     return [RuneError, 0]
   }
 
   // Simple implementation - find the start of the last rune
-  let start = p.length - 1
-  while (start > 0 && !RuneStart(p[start])) {
+  let start = bytes.length - 1
+  while (start > 0 && !RuneStart(bytes[start])) {
     start--
   }
 
-  const [r, size] = DecodeRune(p.slice(start))
-  if (start + size !== p.length) {
+  const [r, size] = DecodeRune(bytes.slice(start))
+  if (start + size !== bytes.length) {
     return [RuneError, 1]
   }
   return [r, size]
@@ -141,17 +142,28 @@ export function EncodeRune(p: Uint8Array | $.Slice<number>, r: number): number {
 }
 
 // FullRune reports whether the bytes in p begin with a full UTF-8 encoding of a rune.
-export function FullRune(p: Uint8Array): boolean {
-  if (p.length === 0) {
+export function FullRune(p: $.Bytes): boolean {
+  if ($.len(p) === 0) {
     return false
   }
 
-  if (p[0] < RuneSelf) {
+  const first = $.indexStringOrBytes(p, 0)
+  if (first < RuneSelf) {
     return true
   }
-
-  const [, size] = DecodeRune(p)
-  return size <= p.length && size > 0
+  if (first < 0xc0) {
+    return true
+  }
+  if (first < 0xe0) {
+    return $.len(p) >= 2
+  }
+  if (first < 0xf0) {
+    return $.len(p) >= 3
+  }
+  if (first < 0xf8) {
+    return $.len(p) >= 4
+  }
+  return true
 }
 
 // FullRuneInString is like FullRune but its input is a string.
@@ -170,9 +182,9 @@ export function FullRuneInString(s: string): boolean {
 }
 
 // RuneCount returns the number of runes in p.
-export function RuneCount(p: Uint8Array): number {
+export function RuneCount(p: $.Bytes): number {
   const decoder = new TextDecoder('utf-8', { fatal: false })
-  const str = decoder.decode(p)
+  const str = decoder.decode($.bytesToUint8Array(p))
   return [...str].length
 }
 
@@ -202,10 +214,10 @@ export function RuneStart(b: number): boolean {
 }
 
 // Valid reports whether p consists entirely of valid UTF-8-encoded runes.
-export function Valid(p: Uint8Array): boolean {
+export function Valid(p: $.Bytes): boolean {
   try {
     const decoder = new TextDecoder('utf-8', { fatal: true })
-    decoder.decode(p)
+    decoder.decode($.bytesToUint8Array(p))
     return true
   } catch {
     return false

package/gs/unique/index.ts

@@ -0,0 +1,98 @@
+import * as $ from '@goscript/builtin/index.js'
+
+const handles = new Map<string, Handle<any>>()
+
+export class Handle<T = any> {
+  private readonly value: T | undefined
+
+  constructor(init?: Partial<{ value?: T }> | T) {
+    if (init && typeof init === 'object' && 'value' in init) {
+      this.value = init.value
+    } else {
+      this.value = init as T | undefined
+    }
+  }
+
+  public Value(): T {
+    return this.value as T
+  }
+
+  public clone(): Handle<T> {
+    return this
+  }
+
+  static __typeInfo = $.registerStructType(
+    'unique.Handle',
+    new Handle(),
+    [{ name: 'Value', args: [], returns: [] }],
+    Handle,
+    { value: { kind: $.TypeKind.Interface, methods: [] } },
+  )
+}
+
+export function Make<T = any>(
+  typeArgsOrValue: $.GenericTypeArgs | T | undefined,
+  maybeValue?: T,
+): Handle<T> {
+  const value = arguments.length === 1 ? (typeArgsOrValue as T) : maybeValue
+  const key = stableKey(value)
+  const existing = handles.get(key)
+  if (existing) {
+    return existing as Handle<T>
+  }
+  const handle = new Handle<T>({ value })
+  handles.set(key, handle)
+  return handle
+}
+
+function stableKey(value: unknown): string {
+  const seen = new WeakMap<object, number>()
+  let nextID = 0
+  return JSON.stringify(normalize(value, seen, () => nextID++))
+}
+
+function normalize(
+  value: unknown,
+  seen: WeakMap<object, number>,
+  nextID: () => number,
+): unknown {
+  if (value == null || typeof value !== 'object') {
+    return value
+  }
+  const cached = seen.get(value)
+  if (cached !== undefined) {
+    return { $ref: cached }
+  }
+  seen.set(value, nextID())
+  if ($.isVarRef(value)) {
+    return { $varRef: normalize(value.value, seen, nextID) }
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalize(entry, seen, nextID))
+  }
+  if (value instanceof Map) {
+    return {
+      $map: [...value.entries()]
+        .map(([key, entry]) => [
+          normalize(key, seen, nextID),
+          normalize(entry, seen, nextID),
+        ])
+        .sort(([a], [b]) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
+    }
+  }
+  if (
+    '_fields' in value &&
+    value._fields &&
+    typeof value._fields === 'object'
+  ) {
+    return {
+      $type: value.constructor.name,
+      $fields: normalize(value._fields, seen, nextID),
+    }
+  }
+  const entries = Object.entries(value)
+    .filter(([, entry]) => typeof entry !== 'function')
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, entry]) => [key, normalize(entry, seen, nextID)])
+  return { $object: entries }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -104,8 +104,9 @@
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.0.2",
     "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
+    "lint-staged": "^17.0.0",
     "prettier": "^3.8.1",
+    "starpc": "0.49.15",
     "typescript": "^6.0.0",
     "typescript-eslint": "^8.58.0",
     "vitest": "^4.1.2"