goscript 0.0.25 → 0.0.28

package/gs/unicode/unicode.ts

@@ -0,0 +1,418 @@
+// Package unicode provides data and functions to test some properties of Unicode code points.
+
+// Constants
+export const MaxRune = 0x10ffff
+export const ReplacementChar = 0xfffd
+export const MaxASCII = 0x7f
+export const MaxLatin1 = 0xff
+export const Version = '15.0.0'
+
+// Case constants
+export const UpperCase = 0
+export const LowerCase = 1
+export const TitleCase = 2
+export const MaxCase = 3
+
+export const UpperLower = MaxRune + 1
+
+// Range16 represents a range of 16-bit Unicode code points
+export class Range16 {
+  public Lo: number
+  public Hi: number
+  public Stride: number
+
+  constructor(lo: number, hi: number, stride: number) {
+    this.Lo = lo
+    this.Hi = hi
+    this.Stride = stride
+  }
+
+  public clone(): Range16 {
+    return new Range16(this.Lo, this.Hi, this.Stride)
+  }
+}
+
+// Range32 represents a range of 32-bit Unicode code points
+export class Range32 {
+  public Lo: number
+  public Hi: number
+  public Stride: number
+
+  constructor(lo: number, hi: number, stride: number) {
+    this.Lo = lo
+    this.Hi = hi
+    this.Stride = stride
+  }
+
+  public clone(): Range32 {
+    return new Range32(this.Lo, this.Hi, this.Stride)
+  }
+}
+
+// RangeTable defines a set of Unicode code points by listing the ranges of code points within the set
+export class RangeTable {
+  public R16: Range16[]
+  public R32: Range32[]
+  public LatinOffset: number
+
+  constructor(
+    r16: Range16[] = [],
+    r32: Range32[] = [],
+    latinOffset: number = 0,
+  ) {
+    this.R16 = r16
+    this.R32 = r32
+    this.LatinOffset = latinOffset
+  }
+
+  public clone(): RangeTable {
+    return new RangeTable(
+      this.R16.map((r) => r.clone()),
+      this.R32.map((r) => r.clone()),
+      this.LatinOffset,
+    )
+  }
+}
+
+// CaseRange represents a range of Unicode code points for case mapping
+export class CaseRange {
+  public Lo: number
+  public Hi: number
+  public Delta: [number, number, number]
+
+  constructor(lo: number, hi: number, delta: [number, number, number]) {
+    this.Lo = lo
+    this.Hi = hi
+    this.Delta = delta
+  }
+
+  public clone(): CaseRange {
+    return new CaseRange(this.Lo, this.Hi, [...this.Delta] as [
+      number,
+      number,
+      number,
+    ])
+  }
+}
+
+// SpecialCase represents language-specific case mappings
+export type SpecialCase = CaseRange[]
+
+// Basic character classification functions using JavaScript's built-in Unicode support
+
+// IsControl reports whether the rune is a control character
+export function IsControl(r: number): boolean {
+  // Control characters are in categories Cc, Cf, Co, Cs
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  // Use regex to match control characters
+  return /[\p{Cc}\p{Cf}\p{Co}\p{Cs}]/u.test(char)
+}
+
+// IsDigit reports whether the rune is a decimal digit
+export function IsDigit(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{Nd}/u.test(char)
+}
+
+// IsGraphic reports whether the rune is defined as a Graphic by Unicode
+export function IsGraphic(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  return IsLetter(r) || IsMark(r) || IsNumber(r) || IsPunct(r) || IsSymbol(r)
+}
+
+// IsLetter reports whether the rune is a letter (category L)
+export function IsLetter(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{L}/u.test(char)
+}
+
+// IsLower reports whether the rune is a lower case letter
+export function IsLower(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{Ll}/u.test(char)
+}
+
+// IsMark reports whether the rune is a mark character (category M)
+export function IsMark(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{M}/u.test(char)
+}
+
+// IsNumber reports whether the rune is a number (category N)
+export function IsNumber(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{N}/u.test(char)
+}
+
+// IsPrint reports whether the rune is defined as printable by Go
+export function IsPrint(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  if (IsGraphic(r)) return true
+  return r === 0x20 // space character
+}
+
+// IsPunct reports whether the rune is a punctuation character (category P)
+export function IsPunct(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{P}/u.test(char)
+}
+
+// IsSpace reports whether the rune is a space character
+export function IsSpace(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\s/u.test(char) || /\p{Z}/u.test(char)
+}
+
+// IsSymbol reports whether the rune is a symbol character (category S)
+export function IsSymbol(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{S}/u.test(char)
+}
+
+// IsTitle reports whether the rune is a title case letter
+export function IsTitle(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{Lt}/u.test(char)
+}
+
+// IsUpper reports whether the rune is an upper case letter
+export function IsUpper(r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+  const char = String.fromCodePoint(r)
+  return /\p{Lu}/u.test(char)
+}
+
+// Case conversion functions
+
+// ToLower returns the lowercase mapping of the rune
+export function ToLower(r: number): number {
+  if (r < 0 || r > MaxRune) return r
+  const char = String.fromCodePoint(r)
+  const lower = char.toLowerCase()
+  return lower.codePointAt(0) || r
+}
+
+// ToUpper returns the uppercase mapping of the rune
+export function ToUpper(r: number): number {
+  if (r < 0 || r > MaxRune) return r
+  const char = String.fromCodePoint(r)
+  const upper = char.toUpperCase()
+  return upper.codePointAt(0) || r
+}
+
+// ToTitle returns the title case mapping of the rune
+export function ToTitle(r: number): number {
+  // For most characters, title case is the same as uppercase
+  return ToUpper(r)
+}
+
+// To returns the case mapping of the rune
+export function To(_case: number, r: number): number {
+  switch (_case) {
+    case UpperCase:
+      return ToUpper(r)
+    case LowerCase:
+      return ToLower(r)
+    case TitleCase:
+      return ToTitle(r)
+    default:
+      return r
+  }
+}
+
+// SimpleFold returns the next rune in the simple case folding sequence
+export function SimpleFold(r: number): number {
+  if (r < 0 || r > MaxRune) return r
+
+  // Simple implementation - just toggle between upper and lower case
+  if (IsUpper(r)) {
+    return ToLower(r)
+  } else if (IsLower(r)) {
+    return ToUpper(r)
+  }
+  return r
+}
+
+// Is reports whether the rune is in the specified table of ranges
+export function Is(rangeTab: RangeTable, r: number): boolean {
+  if (r < 0 || r > MaxRune) return false
+
+  // Check 16-bit ranges
+  for (const range of rangeTab.R16) {
+    if (r < range.Lo) break
+    if (r <= range.Hi) {
+      return range.Stride === 1 || (r - range.Lo) % range.Stride === 0
+    }
+  }
+
+  // Check 32-bit ranges
+  for (const range of rangeTab.R32) {
+    if (r < range.Lo) break
+    if (r <= range.Hi) {
+      return range.Stride === 1 || (r - range.Lo) % range.Stride === 0
+    }
+  }
+
+  return false
+}
+
+// In reports whether the rune is a member of one of the ranges
+export function In(r: number, ...ranges: RangeTable[]): boolean {
+  for (const rangeTab of ranges) {
+    if (Is(rangeTab, r)) {
+      return true
+    }
+  }
+  return false
+}
+
+// IsOneOf reports whether the rune is a member of one of the ranges
+export function IsOneOf(ranges: RangeTable[], r: number): boolean {
+  return In(r, ...ranges)
+}
+
+// Predefined range tables for common character categories
+// These are simplified versions - in a full implementation, these would contain
+// the complete Unicode range data
+
+export const Letter = new RangeTable(
+  [new Range16(0x0041, 0x005a, 1), new Range16(0x0061, 0x007a, 1)], // Basic Latin letters
+  [],
+)
+
+export const Digit = new RangeTable(
+  [new Range16(0x0030, 0x0039, 1)], // ASCII digits
+  [],
+)
+
+export const Space = new RangeTable(
+  [new Range16(0x0009, 0x000d, 1), new Range16(0x0020, 0x0020, 1)], // Basic whitespace
+  [],
+)
+
+export const Upper = new RangeTable(
+  [new Range16(0x0041, 0x005a, 1)], // ASCII uppercase
+  [],
+)
+
+export const Lower = new RangeTable(
+  [new Range16(0x0061, 0x007a, 1)], // ASCII lowercase
+  [],
+)
+
+export const Title = new RangeTable([], [])
+
+export const Punct = new RangeTable(
+  [
+    new Range16(0x0021, 0x002f, 1), // !"#$%&'()*+,-./
+    new Range16(0x003a, 0x0040, 1), // :;<=>?@
+    new Range16(0x005b, 0x0060, 1), // [\]^_`
+    new Range16(0x007b, 0x007e, 1), // {|}~
+  ],
+  [],
+)
+
+export const Symbol = new RangeTable([], [])
+
+export const Mark = new RangeTable([], [])
+
+export const Number = new RangeTable(
+  [new Range16(0x0030, 0x0039, 1)], // ASCII digits
+  [],
+)
+
+// Categories map
+export const Categories = new Map<string, RangeTable>([
+  ['L', Letter],
+  ['Ll', Lower],
+  ['Lu', Upper],
+  ['Lt', Title],
+  ['M', Mark],
+  ['N', Number],
+  ['Nd', Digit],
+  ['P', Punct],
+  ['S', Symbol],
+  ['Z', Space],
+])
+
+// Scripts and Properties maps (simplified)
+export const Scripts = new Map<string, RangeTable>()
+export const Properties = new Map<string, RangeTable>()
+export const FoldCategory = new Map<string, RangeTable>()
+export const FoldScript = new Map<string, RangeTable>()
+
+// Graphic ranges
+export const GraphicRanges = [Letter, Mark, Number, Punct, Symbol]
+
+// Print ranges
+export const PrintRanges = [Letter, Mark, Number, Punct, Symbol, Space]
+
+// Case ranges (simplified)
+export const CaseRanges: CaseRange[] = []
+
+// Special cases
+export const TurkishCase: SpecialCase = []
+export const AzeriCase: SpecialCase = TurkishCase
+
+// Predefined character categories (simplified implementations)
+export const Cc = new RangeTable(
+  [new Range16(0x0000, 0x001f, 1), new Range16(0x007f, 0x009f, 1)],
+  [],
+)
+export const Cf = new RangeTable([], [])
+export const Co = new RangeTable([], [])
+export const Cs = new RangeTable([new Range16(0xd800, 0xdfff, 1)], [])
+export const Lm = new RangeTable([], [])
+export const Lo = new RangeTable([], [])
+export const Mc = new RangeTable([], [])
+export const Me = new RangeTable([], [])
+export const Mn = new RangeTable([], [])
+export const Nl = new RangeTable([], [])
+export const No = new RangeTable([], [])
+export const Pc = new RangeTable([new Range16(0x005f, 0x005f, 1)], []) // underscore
+export const Pd = new RangeTable([new Range16(0x002d, 0x002d, 1)], []) // hyphen
+export const Pe = new RangeTable(
+  [
+    new Range16(0x0029, 0x0029, 1),
+    new Range16(0x005d, 0x005d, 1),
+    new Range16(0x007d, 0x007d, 1),
+  ],
+  [],
+)
+export const Pf = new RangeTable([], [])
+export const Pi = new RangeTable([], [])
+export const Po = new RangeTable(
+  [new Range16(0x0021, 0x0023, 1), new Range16(0x0025, 0x0027, 1)],
+  [],
+)
+export const Ps = new RangeTable(
+  [
+    new Range16(0x0028, 0x0028, 1),
+    new Range16(0x005b, 0x005b, 1),
+    new Range16(0x007b, 0x007b, 1),
+  ],
+  [],
+)
+export const Sc = new RangeTable([new Range16(0x0024, 0x0024, 1)], []) // dollar sign
+export const Sk = new RangeTable(
+  [new Range16(0x005e, 0x005e, 1), new Range16(0x0060, 0x0060, 1)],
+  [],
+)
+export const Sm = new RangeTable(
+  [new Range16(0x002b, 0x002b, 1), new Range16(0x003c, 0x003e, 1)],
+  [],
+)
+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

package/gs/unicode/utf8/godoc.txt

@@ -0,0 +1,22 @@
+package utf8 // import "unicode/utf8"
+
+Package utf8 implements functions and constants to support text encoded
+in UTF-8. It includes functions to translate between runes and UTF-8 byte
+sequences. See https://en.wikipedia.org/wiki/UTF-8
+
+const RuneError = '\uFFFD' ...
+func AppendRune(p []byte, r rune) []byte
+func DecodeLastRune(p []byte) (r rune, size int)
+func DecodeLastRuneInString(s string) (r rune, size int)
+func DecodeRune(p []byte) (r rune, size int)
+func DecodeRuneInString(s string) (r rune, size int)
+func EncodeRune(p []byte, r rune) int
+func FullRune(p []byte) bool
+func FullRuneInString(s string) bool
+func RuneCount(p []byte) int
+func RuneCountInString(s string) (n int)
+func RuneLen(r rune) int
+func RuneStart(b byte) bool
+func Valid(p []byte) bool
+func ValidRune(r rune) bool
+func ValidString(s string) bool

package/gs/unicode/utf8/index.ts

@@ -0,0 +1,2 @@
+// Package utf8 implements functions and constants to support text encoded in UTF-8.
+export * from './utf8.js'

package/gs/unicode/utf8/utf8.ts

@@ -0,0 +1,227 @@
+// Package utf8 implements functions and constants to support text encoded in UTF-8.
+
+import * as $ from '@goscript/builtin/builtin.js'
+
+// RuneError is the "error" Rune or "Unicode replacement character"
+export const RuneError = 0xfffd
+
+// RuneSelf is the maximum rune value that can be represented as a single byte.
+export const RuneSelf = 0x80
+
+// MaxRune is the maximum valid Unicode code point.
+export const MaxRune = 0x10ffff
+
+// UTFMax is the maximum number of bytes of a UTF-8 encoded Unicode character.
+export const UTFMax = 4
+
+// AppendRune appends the UTF-8 encoding of r to the end of p and returns the extended buffer.
+export function AppendRune(p: Uint8Array, r: number): Uint8Array {
+  const temp = new Uint8Array(UTFMax)
+  const n = EncodeRune(temp, r)
+  const result = new Uint8Array(p.length + n)
+  result.set(p)
+  result.set(temp.slice(0, n), p.length)
+  return result
+}
+
+// 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) {
+    return [RuneError, 0]
+  }
+
+  // Simple implementation - find the start of the last rune
+  let start = p.length - 1
+  while (start > 0 && !RuneStart(p[start])) {
+    start--
+  }
+
+  const [r, size] = DecodeRune(p.slice(start))
+  if (start + size !== p.length) {
+    return [RuneError, 1]
+  }
+  return [r, size]
+}
+
+// DecodeLastRuneInString is like DecodeLastRune but its input is a string.
+export function DecodeLastRuneInString(s: string): [number, number] {
+  if (s.length === 0) {
+    return [RuneError, 0]
+  }
+
+  // Use JavaScript's built-in Unicode handling
+  const chars = [...s]
+  if (chars.length === 0) {
+    return [RuneError, 0]
+  }
+
+  const lastChar = chars[chars.length - 1]
+  const codePoint = lastChar.codePointAt(0) || RuneError
+  const encoder = new TextEncoder()
+  const encoded = encoder.encode(lastChar)
+  return [codePoint, encoded.length]
+}
+
+// DecodeRune unpacks the first UTF-8 encoding in p and returns the rune and its width in bytes.
+export function DecodeRune(p: Uint8Array): [number, number] {
+  if (p.length === 0) {
+    return [RuneError, 0]
+  }
+
+  if (p[0] < RuneSelf) {
+    return [p[0], 1]
+  }
+
+  // Convert bytes to string and decode
+  const decoder = new TextDecoder('utf-8', { fatal: false })
+  const str = decoder.decode(p.slice(0, Math.min(4, p.length)))
+  if (str.length === 0 || str === '\uFFFD') {
+    return [RuneError, 1]
+  }
+
+  const codePoint = str.codePointAt(0) || RuneError
+  const char = String.fromCodePoint(codePoint)
+  const encoder = new TextEncoder()
+  const encoded = encoder.encode(char)
+  return [codePoint, encoded.length]
+}
+
+// DecodeRuneInString is like DecodeRune but its input is a string.
+export function DecodeRuneInString(s: string): [number, number] {
+  if (s.length === 0) {
+    return [RuneError, 0]
+  }
+
+  const c = s.charCodeAt(0)
+  if (c < RuneSelf) {
+    return [c, 1]
+  }
+
+  // Use JavaScript's built-in Unicode handling
+  const codePoint = s.codePointAt(0) || RuneError
+  const char = String.fromCodePoint(codePoint)
+  const encoder = new TextEncoder()
+  const encoded = encoder.encode(char)
+  return [codePoint, encoded.length]
+}
+
+// EncodeRune writes into p (which must be large enough) the UTF-8 encoding of the rune.
+export function EncodeRune(p: Uint8Array | $.Slice<number>, r: number): number {
+  if (p === null) return 0
+
+  if (!ValidRune(r)) {
+    r = RuneError
+  }
+
+  const str = String.fromCodePoint(r)
+  const encoder = new TextEncoder()
+  const encoded = encoder.encode(str)
+
+  // Handle both Uint8Array and Slice types
+  if (p instanceof Uint8Array) {
+    for (let i = 0; i < Math.min(encoded.length, p.length); i++) {
+      p[i] = encoded[i]
+    }
+    return Math.min(encoded.length, p.length)
+  } else {
+    // Handle Slice<number>
+    const len = $.len(p!)
+    for (let i = 0; i < Math.min(encoded.length, len); i++) {
+      ;(p as $.Slice<number>)![i] = encoded[i]
+    }
+    return Math.min(encoded.length, len)
+  }
+}
+
+// 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) {
+    return false
+  }
+
+  if (p[0] < RuneSelf) {
+    return true
+  }
+
+  const [, size] = DecodeRune(p)
+  return size <= p.length && size > 0
+}
+
+// FullRuneInString is like FullRune but its input is a string.
+export function FullRuneInString(s: string): boolean {
+  if (s.length === 0) {
+    return false
+  }
+
+  const c = s.charCodeAt(0)
+  if (c < RuneSelf) {
+    return true
+  }
+
+  const [, size] = DecodeRuneInString(s)
+  return size <= s.length && size > 0
+}
+
+// RuneCount returns the number of runes in p.
+export function RuneCount(p: Uint8Array): number {
+  const decoder = new TextDecoder('utf-8', { fatal: false })
+  const str = decoder.decode(p)
+  return [...str].length
+}
+
+// RuneCountInString is like RuneCount but its input is a string.
+export function RuneCountInString(s: string): number {
+  return [...s].length
+}
+
+// RuneLen returns the number of bytes required to encode the rune.
+export function RuneLen(r: number): number {
+  if (!ValidRune(r)) {
+    return -1
+  }
+
+  if (r < RuneSelf) {
+    return 1
+  }
+
+  const str = String.fromCodePoint(r)
+  const encoder = new TextEncoder()
+  return encoder.encode(str).length
+}
+
+// RuneStart reports whether the byte could be the first byte of an encoded, possibly invalid rune.
+export function RuneStart(b: number): boolean {
+  return (b & 0xc0) !== 0x80
+}
+
+// Valid reports whether p consists entirely of valid UTF-8-encoded runes.
+export function Valid(p: Uint8Array): boolean {
+  try {
+    const decoder = new TextDecoder('utf-8', { fatal: true })
+    decoder.decode(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ValidRune reports whether r can be legally encoded as UTF-8.
+export function ValidRune(r: number): boolean {
+  return r >= 0 && r <= MaxRune && !(r >= 0xd800 && r <= 0xdfff)
+}
+
+// ValidString reports whether s consists entirely of valid UTF-8-encoded runes.
+export function ValidString(s: string): boolean {
+  // JavaScript strings are always valid UTF-16, but we check for surrogates
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i)
+    if (code >= 0xd800 && code <= 0xdfff) {
+      // Surrogate pair
+      if (i + 1 >= s.length) return false
+      const next = s.charCodeAt(i + 1)
+      if (code >= 0xdc00 || next < 0xdc00 || next > 0xdfff) return false
+      i++ // Skip the next character as it's part of the surrogate pair
+    }
+  }
+  return true
+}

package/gs/unsafe/godoc.txt

@@ -0,0 +1,19 @@
+package unsafe // import "unsafe"
+
+Package unsafe contains operations that step around the type safety of Go
+programs.
+
+Packages that import unsafe may be non-portable and are not protected by the Go
+1 compatibility guidelines.
+
+func Alignof(x ArbitraryType) uintptr
+func Offsetof(x ArbitraryType) uintptr
+func Sizeof(x ArbitraryType) uintptr
+func String(ptr *byte, len IntegerType) string
+func StringData(str string) *byte
+type ArbitraryType int
+    func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
+    func SliceData(slice []ArbitraryType) *ArbitraryType
+type IntegerType int
+type Pointer *ArbitraryType
+    func Add(ptr Pointer, len IntegerType) Pointer

package/gs/unsafe/index.ts

@@ -0,0 +1 @@
+export * from './unsafe.js'