goscript 0.1.4 → 0.2.1

package/dist/gs/encoding/json/index.js

@@ -1,4 +1,185 @@
 import * as $ from '@goscript/builtin/index.js';
+import * as bytes from '@goscript/bytes/index.js';
+class jsonError extends Error {
+    Error() {
+        return this.message;
+    }
+}
+export class SyntaxError extends jsonError {
+    Offset;
+    constructor(init) {
+        super(init?.Message ?? 'invalid character in JSON');
+        this.name = 'SyntaxError';
+        this.Offset = init?.Offset ?? 0;
+    }
+}
+export class InvalidUTF8Error extends jsonError {
+    S;
+    constructor(init) {
+        super(`json: invalid UTF-8 in string: ${init?.S ?? ''}`);
+        this.name = 'InvalidUTF8Error';
+        this.S = init?.S ?? '';
+    }
+}
+export class InvalidUnmarshalError extends jsonError {
+    Type;
+    constructor(init) {
+        super('json: Unmarshal(non-pointer)');
+        this.name = 'InvalidUnmarshalError';
+        this.Type = init?.Type ?? null;
+    }
+}
+export class MarshalerError extends jsonError {
+    Type;
+    Err;
+    constructor(init) {
+        super(`json: error calling MarshalJSON: ${init?.Err?.Error?.() ?? ''}`);
+        this.name = 'MarshalerError';
+        this.Type = init?.Type ?? null;
+        this.Err = init?.Err ?? null;
+    }
+    Unwrap() {
+        return this.Err;
+    }
+}
+export class UnmarshalFieldError extends jsonError {
+    Key;
+    Type;
+    Field;
+    constructor(init) {
+        super(`json: cannot unmarshal object key ${init?.Key ?? ''}`);
+        this.name = 'UnmarshalFieldError';
+        this.Key = init?.Key ?? '';
+        this.Type = init?.Type ?? null;
+        this.Field = init?.Field ?? null;
+    }
+}
+export class UnmarshalTypeError extends jsonError {
+    Value;
+    Type;
+    Offset;
+    Struct;
+    Field;
+    constructor(init) {
+        super(`json: cannot unmarshal ${init?.Value ?? ''}`);
+        this.name = 'UnmarshalTypeError';
+        this.Value = init?.Value ?? '';
+        this.Type = init?.Type ?? null;
+        this.Offset = init?.Offset ?? 0;
+        this.Struct = init?.Struct ?? '';
+        this.Field = init?.Field ?? '';
+    }
+}
+export class UnsupportedTypeError extends jsonError {
+    Type;
+    constructor(init) {
+        super('json: unsupported type');
+        this.name = 'UnsupportedTypeError';
+        this.Type = init?.Type ?? null;
+    }
+}
+export class UnsupportedValueError extends jsonError {
+    Value;
+    Str;
+    constructor(init) {
+        super(`json: unsupported value: ${init?.Str ?? ''}`);
+        this.name = 'UnsupportedValueError';
+        this.Value = init?.Value ?? null;
+        this.Str = init?.Str ?? '';
+    }
+}
+export class Decoder {
+    reader;
+    disallowUnknownFields = false;
+    inputOffset = 0;
+    useNumber = false;
+    constructor(reader) {
+        this.reader = reader;
+    }
+    Decode(v) {
+        const [data, err] = readAllSync(this.reader);
+        if (err !== null) {
+            return err;
+        }
+        this.inputOffset += $.len(data);
+        return decode(data, v, {
+            disallowUnknownFields: this.disallowUnknownFields,
+            useNumber: this.useNumber,
+        });
+    }
+    Buffered() {
+        return new bytes.Buffer();
+    }
+    DisallowUnknownFields() {
+        this.disallowUnknownFields = true;
+    }
+    InputOffset() {
+        return this.inputOffset;
+    }
+    More() {
+        return false;
+    }
+    Token() {
+        return [null, $.newError('json: token streaming is unsupported')];
+    }
+    UseNumber() {
+        this.useNumber = true;
+    }
+}
+export class Encoder {
+    writer;
+    escapeHTML = true;
+    indent = '';
+    prefix = '';
+    constructor(writer) {
+        this.writer = writer;
+    }
+    Encode(v) {
+        const [data, err] = this.indent === '' && this.prefix === '' ?
+            marshalBytes(v, '', '', this.escapeHTML)
+            : marshalBytes(v, this.prefix, this.indent, this.escapeHTML);
+        if (err !== null) {
+            return err;
+        }
+        const out = $.stringToBytes($.bytesToString(data) + '\n');
+        const [n, writeErr] = this.writer.Write(out);
+        if (writeErr !== null) {
+            return writeErr;
+        }
+        if (n < $.len(out)) {
+            return $.newError('short write');
+        }
+        return null;
+    }
+    SetEscapeHTML(on) {
+        this.escapeHTML = on;
+    }
+    SetIndent(prefix, indent) {
+        this.prefix = prefix;
+        this.indent = indent;
+    }
+}
+export function NewDecoder(r) {
+    return new Decoder(r);
+}
+export function NewEncoder(w) {
+    return new Encoder(w);
+}
+$.registerInterfaceType('json.Marshaler', null, [
+    {
+        name: 'MarshalJSON',
+        args: [],
+        returns: [
+            {
+                type: {
+                    kind: $.TypeKind.Slice,
+                    elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+                },
+            },
+            { type: 'GoError' },
+        ],
+    },
+]);
 $.registerInterfaceType('json.Unmarshaler', null, [
     {
         name: 'UnmarshalJSON',
@@ -15,52 +196,224 @@ $.registerInterfaceType('json.Unmarshaler', null, [
     },
 ]);
 export function Marshal(v) {
+    return marshalBytes(v, '', '', true);
+}
+function marshalBytes(v, prefix, indent, escapeHTML) {
     try {
-        return [$.stringToBytes(JSON.stringify(marshalValue(v))), null];
+        let text = JSON.stringify(marshalValue(v), null, indent);
+        if (escapeHTML) {
+            text = escapeHTMLString(text);
+        }
+        if (prefix !== '') {
+            text = text
+                .split('\n')
+                .map((line, idx) => (idx === 0 ? line : prefix + line))
+                .join('\n');
+        }
+        return [$.stringToBytes(text), null];
     }
     catch (err) {
         return [null, goError(err)];
     }
 }
-export function MarshalIndent(v, prefix, indent) {
+export function Compact(dst, src) {
     try {
-        const text = JSON.stringify(marshalValue(v), null, indent);
-        if (prefix === '') {
-            return [$.stringToBytes(text), null];
+        const text = JSON.stringify(JSON.parse($.bytesToString(src)));
+        const [, err] = $.pointerValue(dst).Write($.stringToBytes(text));
+        return err;
+    }
+    catch (err) {
+        return goError(err);
+    }
+}
+export function HTMLEscape(dst, src) {
+    const escaped = $.bytesToString(src).replace(/[<>&\u2028\u2029]/g, (char) => {
+        switch (char) {
+            case '<':
+                return '\\u003c';
+            case '>':
+                return '\\u003e';
+            case '&':
+                return '\\u0026';
+            case '\u2028':
+                return '\\u2028';
+            case '\u2029':
+                return '\\u2029';
+            default:
+                return char;
         }
-        return [
-            $.stringToBytes(text
-                .split('\n')
-                .map((line, idx) => (idx === 0 ? line : prefix + line))
-                .join('\n')),
-            null,
-        ];
+    });
+    $.pointerValue(dst).Write($.stringToBytes(escaped));
+}
+export function Indent(dst, src, prefix, indent) {
+    try {
+        const text = JSON.stringify(JSON.parse($.bytesToString(src)), null, indent);
+        const prefixed = prefix === '' ? text : (text
+            .split('\n')
+            .map((line, idx) => (idx === 0 ? line : prefix + line))
+            .join('\n'));
+        const [, err] = $.pointerValue(dst).Write($.stringToBytes(prefixed));
+        return err;
     }
     catch (err) {
-        return [null, goError(err)];
+        return goError(err);
     }
 }
+export function MarshalIndent(v, prefix, indent) {
+    return marshalBytes(v, prefix, indent, true);
+}
 export function Unmarshal(data, v) {
+    return decode(data, v, {});
+}
+function decode(data, v, opts) {
     try {
-        assignDecodedValue(v, JSON.parse($.bytesToString(data)));
+        if (!validUnmarshalTarget(v)) {
+            return $.toGoError(new InvalidUnmarshalError());
+        }
+        const unmarshaler = unmarshalJSONTarget(v);
+        if (unmarshaler !== null) {
+            const err = unmarshaler.UnmarshalJSON(data);
+            if (err instanceof Promise) {
+                return $.newError('json: asynchronous UnmarshalJSON is unsupported');
+            }
+            return err;
+        }
+        assignDecodedValue(v, parseJSON(data, opts), opts);
         return null;
     }
     catch (err) {
         return goError(err);
     }
 }
+export function Valid(data) {
+    try {
+        JSON.parse($.bytesToString(data));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function RawMessage_MarshalJSON(m) {
+    if (m === null) {
+        return [$.stringToBytes('null'), null];
+    }
+    const out = $.makeSlice($.len(m), undefined, 'byte');
+    $.copy(out, m);
+    return [out, null];
+}
+export function RawMessage_UnmarshalJSON(m, data) {
+    const out = $.makeSlice($.len(data), undefined, 'byte');
+    $.copy(out, data);
+    if ($.isVarRef(m)) {
+        m.value = out;
+    }
+    return null;
+}
+export function Number_Float64(n) {
+    if (!isValidFloat(n)) {
+        return [0, $.newError(`strconv.ParseFloat: parsing "${n}": invalid syntax`)];
+    }
+    if (/^[+-]?nan$/i.test(n)) {
+        return [Number.NaN, null];
+    }
+    if (/^\+?inf(?:inity)?$/i.test(n)) {
+        return [Infinity, null];
+    }
+    if (/^-inf(?:inity)?$/i.test(n)) {
+        return [-Infinity, null];
+    }
+    const value = Number.parseFloat(n);
+    if (Number.isNaN(value)) {
+        return [0, $.newError(`strconv.ParseFloat: parsing "${n}": invalid syntax`)];
+    }
+    if (!Number.isFinite(value) && !/^[+-]?(?:inf(?:inity)?|nan)$/i.test(n)) {
+        return [
+            value,
+            $.newError(`strconv.ParseFloat: parsing "${n}": value out of range`),
+        ];
+    }
+    return [value, null];
+}
+export function Number_Int64(n) {
+    if (!/^[+-]?\d+$/.test(n)) {
+        return [0, $.newError(`strconv.ParseInt: parsing "${n}": invalid syntax`)];
+    }
+    const value = BigInt(n);
+    const min = -(1n << 63n);
+    const max = (1n << 63n) - 1n;
+    if (value < min || value > max) {
+        const clamped = value < min ? min : max;
+        return [
+            Number(clamped),
+            $.newError(`strconv.ParseInt: parsing "${n}": value out of range`),
+        ];
+    }
+    return [Number(value), null];
+}
+export function Number_String(n) {
+    return n;
+}
+function isValidFloat(value) {
+    return /^[+-]?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|inf(?:inity)?|nan)$/i.test(value);
+}
+function readAllSync(r) {
+    const chunks = [];
+    const buf = $.makeSlice(512, undefined, 'byte');
+    while (true) {
+        const read = r.Read(buf);
+        if (read instanceof Promise) {
+            return [null, $.newError('json: asynchronous reader is unsupported')];
+        }
+        const [n, err] = read;
+        if (n > 0) {
+            chunks.push(...$.bytesToUint8Array($.goSlice(buf, 0, n)));
+        }
+        if (err !== null) {
+            if (err.Error() === 'EOF') {
+                return [new Uint8Array(chunks), null];
+            }
+            return [null, err];
+        }
+    }
+}
 function marshalValue(v) {
+    const marshaler = marshalJSONTarget(v);
+    if (marshaler !== null) {
+        const result = marshaler.MarshalJSON();
+        if (result instanceof Promise) {
+            throw new MarshalerError({
+                Err: $.newError('json: asynchronous MarshalJSON is unsupported'),
+            });
+        }
+        const [data, err] = result;
+        if (err !== null) {
+            throw new MarshalerError({ Err: err });
+        }
+        try {
+            return JSON.parse($.bytesToString(data));
+        }
+        catch (parseErr) {
+            throw new MarshalerError({ Err: goError(parseErr) });
+        }
+    }
     if ($.isVarRef(v)) {
         return marshalValue(v.value);
     }
     if (v === null || v === undefined) {
         return null;
     }
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v)) {
+            throw new UnsupportedValueError({ Value: v, Str: String(v) });
+        }
+        return v;
+    }
     if (typeof v !== 'object') {
         return v;
     }
     if (v instanceof Uint8Array) {
-        return Array.from(v).map(marshalValue);
+        return base64Encode(v);
     }
     if (Array.isArray(v)) {
         return v.map(marshalValue);
@@ -76,20 +429,88 @@ function marshalValue(v) {
         return v;
     }
     const out = {};
-    const typeFields = structFieldMetadata(v);
-    for (const [fieldName, ref] of Object.entries(v._fields)) {
-        const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag);
+    for (const field of structFields(v)) {
+        const ref = v._fields[field.key];
+        if (ref === undefined) {
+            continue;
+        }
+        const jsonName = jsonFieldName(field.name, field.tag);
         if (jsonName === '') {
             continue;
         }
-        out[jsonName] = marshalValue(ref.value);
+        out[jsonName] = marshalFieldValue(ref.value, field.type);
     }
     return out;
 }
-function assignDecodedValue(target, decoded) {
+function marshalFieldValue(value, fieldType) {
+    if (isRawMessageType(fieldType)) {
+        const target = $.isVarRef(value) ? value.value : value;
+        if (target === null || target === undefined) {
+            return null;
+        }
+        try {
+            return JSON.parse($.bytesToString(target));
+        }
+        catch (err) {
+            throw new MarshalerError({ Err: goError(err) });
+        }
+    }
+    return marshalValue(value);
+}
+function marshalJSONTarget(value) {
+    const target = $.isVarRef(value) ? value.value : value;
+    if (target === null || target === undefined) {
+        return null;
+    }
+    if (typeof target !== 'object' && typeof target !== 'function') {
+        return null;
+    }
+    const method = Reflect.get(target, 'MarshalJSON');
+    return typeof method === 'function' ? target : null;
+}
+function unmarshalJSONTarget(value) {
+    const target = $.isVarRef(value) ? value.value : value;
+    if (target === null || target === undefined) {
+        return null;
+    }
+    if (typeof target !== 'object' && typeof target !== 'function') {
+        return null;
+    }
+    const method = Reflect.get(target, 'UnmarshalJSON');
+    return typeof method === 'function' ? target : null;
+}
+function validUnmarshalTarget(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if ($.isVarRef(value)) {
+        return true;
+    }
+    return unmarshalJSONTarget(value) !== null || isStructValue(value);
+}
+function parseJSON(data, opts) {
+    const text = $.bytesToString(data);
+    if (opts.useNumber) {
+        return JSON.parse(text, (_key, value) => typeof value === 'number' ? String(value) : value);
+    }
+    return JSON.parse(text);
+}
+function assignDecodedValue(target, decoded, opts) {
     if ($.isVarRef(target)) {
+        const unmarshaler = unmarshalJSONTarget(target.value);
+        if (unmarshaler !== null) {
+            const err = unmarshaler.UnmarshalJSON($.stringToBytes(JSON.stringify(decoded)));
+            if (err !== null) {
+                throw err;
+            }
+            return;
+        }
         if (isStructValue(target.value) && isPlainObject(decoded)) {
-            assignStructFields(target.value, decoded);
+            assignStructFields(target.value, decoded, opts);
+            return;
+        }
+        if (target.value instanceof Uint8Array && typeof decoded === 'string') {
+            target.value = base64Decode(decoded);
             return;
         }
         if (isPlainObject(decoded)) {
@@ -100,19 +521,44 @@ function assignDecodedValue(target, decoded) {
         return;
     }
     if (isStructValue(target) && isPlainObject(decoded)) {
-        assignStructFields(target, decoded);
+        assignStructFields(target, decoded, opts);
     }
 }
-function assignStructFields(target, decoded) {
-    const typeFields = structFieldMetadata(target);
-    for (const [fieldName, ref] of Object.entries(target._fields)) {
-        const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag);
+function assignStructFields(target, decoded, opts) {
+    const fields = structFields(target);
+    const knownNames = new Set();
+    for (const field of fields) {
+        const jsonName = jsonFieldName(field.name, field.tag);
+        if (jsonName !== '') {
+            knownNames.add(jsonName);
+        }
+    }
+    if (opts.disallowUnknownFields) {
+        for (const key of Object.keys(decoded)) {
+            if (!knownNames.has(key)) {
+                throw $.newError(`json: unknown field "${key}"`);
+            }
+        }
+    }
+    for (const field of fields) {
+        const ref = target._fields[field.key];
+        if (ref === undefined) {
+            continue;
+        }
+        const jsonName = jsonFieldName(field.name, field.tag);
         if (jsonName !== '' &&
             Object.prototype.hasOwnProperty.call(decoded, jsonName)) {
-            ref.value = decoded[jsonName];
+            assignDecodedFieldValue(ref, decoded[jsonName], opts, field.type);
         }
     }
 }
+function assignDecodedFieldValue(target, decoded, opts, fieldType) {
+    if (isRawMessageType(fieldType)) {
+        target.value = $.stringToBytes(JSON.stringify(decoded));
+        return;
+    }
+    assignDecodedValue(target, decoded, opts);
+}
 function objectToMap(decoded) {
     const out = new Map();
     for (const [key, value] of Object.entries(decoded)) {
@@ -137,42 +583,104 @@ function isPlainObject(value) {
         !(value instanceof Uint8Array) &&
         !(value instanceof Map));
 }
+function structFields(value) {
+    const fields = structFieldMetadata(value);
+    if (fields.length !== 0) {
+        return fields;
+    }
+    return Object.keys(value._fields).map((key) => ({ key, name: key }));
+}
 function structFieldMetadata(value) {
     if (value === null || typeof value !== 'object') {
-        return {};
+        return [];
     }
     const ctor = Reflect.get(value, 'constructor');
     if (ctor === null ||
         ctor === undefined ||
         (typeof ctor !== 'object' && typeof ctor !== 'function')) {
-        return {};
+        return [];
     }
     const typeInfo = Reflect.get(ctor, '__typeInfo');
     if (typeInfo === null ||
         typeInfo === undefined ||
         typeof typeInfo !== 'object') {
-        return {};
+        return [];
     }
     const fields = Reflect.get(typeInfo, 'fields');
-    if (isPlainObject(fields)) {
-        const out = {};
-        for (const [name, field] of Object.entries(fields)) {
-            if (!isPlainObject(field)) {
+    if (Array.isArray(fields)) {
+        const out = [];
+        for (const field of fields) {
+            if (!$.isStructFieldInfo(field)) {
                 continue;
             }
             const tag = field.tag;
-            out[name] = typeof tag === 'string' ? { tag } : {};
+            out.push({
+                key: $.structFieldRuntimeKey(field),
+                name: field.name,
+                type: field.type,
+                ...(typeof tag === 'string' ? { tag } : {}),
+            });
         }
         return out;
     }
-    return {};
+    return [];
+}
+function isRawMessageType(value) {
+    if (value === 'json.RawMessage' || value === 'encoding/json.RawMessage') {
+        return true;
+    }
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return (value.typeName === 'json.RawMessage' ||
+        value.typeName === 'encoding/json.RawMessage' ||
+        value.name === 'json.RawMessage' ||
+        value.name === 'encoding/json.RawMessage');
 }
 function goError(err) {
+    if (err !== null &&
+        typeof err === 'object' &&
+        typeof err.Error === 'function') {
+        return err;
+    }
     if (err instanceof Error) {
         return $.toGoError(err);
     }
     return $.newError(String(err));
 }
+function base64Encode(data) {
+    let binary = '';
+    for (const byte of data) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+function base64Decode(text) {
+    const binary = atob(text);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        out[i] = binary.charCodeAt(i);
+    }
+    return out;
+}
+function escapeHTMLString(text) {
+    return text.replace(/[<>&\u2028\u2029]/g, (char) => {
+        switch (char) {
+            case '<':
+                return '\\u003c';
+            case '>':
+                return '\\u003e';
+            case '&':
+                return '\\u0026';
+            case '\u2028':
+                return '\\u2028';
+            case '\u2029':
+                return '\\u2029';
+            default:
+                return char;
+        }
+    });
+}
 function jsonFieldName(fieldName, tag) {
     if (tag === undefined || !tag.startsWith('json:"')) {
         return fieldName;