omlish 0.0.0.dev213__py3-none-any.whl → 0.0.0.dev214__py3-none-any.whl

omlish/.manifests.json

@@ -108,13 +108,13 @@
     }
   },
   {
-    "module": ".formats.json5",
+    "module": ".formats.json5.codec",
     "attr": "_JSON5_LAZY_CODEC",
-    "file": "omlish/formats/json5.py",
-    "line": 30,
+    "file": "omlish/formats/json5/codec.py",
+    "line": 25,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
-        "mod_name": "omlish.formats.json5",
+        "mod_name": "omlish.formats.json5.codec",
         "attr_name": "JSON5_CODEC",
         "name": "json5",
         "aliases": null

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev213'
-__revision__ = '03c9d6a7f92cec54535af989bf531b8598a896c0'
+__version__ = '0.0.0.dev214'
+__revision__ = '9512c6d71a63bb51772d9183f0205459f229de64'
 
 
 #
@@ -54,7 +54,7 @@ class Project(ProjectBase):
 
         'diag': [
             'asttokens ~= 3.0',
-            'executing ~= 2.1',
+            'executing ~= 2.2',
 
             'psutil ~= 6.0',
         ],
@@ -63,8 +63,6 @@ class Project(ProjectBase):
             'orjson ~= 3.10',
             'ujson ~= 5.10',
 
-            'json5 ~= 0.9',
-
             'pyyaml ~= 6.0',
 
             'cbor2 ~= 5.6',

omlish/antlr/__init__.py

@@ -0,0 +1,3 @@
+from . import errors  # noqa
+from . import parsing  # noqa
+from . import runtime  # noqa

omlish/antlr/parsing.py

@@ -1,19 +1,51 @@
 # ruff: noqa: N802 N803
 import typing as ta
 
+from .. import check
 from . import runtime as antlr4
+from .errors import SilentRaisingErrorListener
 
 
 LexerT = ta.TypeVar('LexerT', bound=antlr4.Lexer)
 ParserT = ta.TypeVar('ParserT', bound=antlr4.Parser)
 
 
-def parse(
+def is_eof_context(ctx: antlr4.ParserRuleContext) -> bool:
+    return ctx.getChildCount() == 1 and ctx.getChild(0).getSymbol().type == antlr4.Token.EOF
+
+
+class StandardParseTreeVisitor(antlr4.ParseTreeVisitor):
+    def visit(self, ctx: antlr4.ParserRuleContext):
+        check.isinstance(ctx, antlr4.ParserRuleContext)
+        return ctx.accept(self)
+
+    def aggregateResult(self, aggregate, nextResult):  # noqa
+        if aggregate is not None:
+            check.none(nextResult)
+            return aggregate
+        else:
+            check.none(aggregate)
+            return nextResult
+
+
+def make_parser(
         buf: str,
         lexer_cls: type[LexerT],
         parser_cls: type[ParserT],
+        *,
+        silent_errors: bool = False,
 ) -> ParserT:
     lexer = lexer_cls(antlr4.InputStream(buf))
+    if silent_errors:
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(SilentRaisingErrorListener())
+
     stream = antlr4.CommonTokenStream(lexer)
     stream.fill()
-    return parser_cls(stream)
+
+    parser = parser_cls(stream)
+    if silent_errors:
+        parser.removeErrorListeners()
+        parser.addErrorListener(SilentRaisingErrorListener())
+
+    return parser

omlish/asyncs/asyncio/asyncio.py

@@ -1,9 +1,13 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import asyncio
 import contextlib
 import functools
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 
@@ -36,3 +40,33 @@ def draining_asyncio_tasks() -> ta.Iterator[None]:
     finally:
         if loop is not None:
             drain_tasks(loop)  # noqa
+
+
+async def asyncio_wait_concurrent(
+        coros: ta.Iterable[ta.Awaitable[T]],
+        concurrency: ta.Union[int, asyncio.Semaphore],
+        *,
+        return_when: ta.Any = asyncio.FIRST_EXCEPTION,
+) -> ta.List[T]:
+    if isinstance(concurrency, asyncio.Semaphore):
+        semaphore = concurrency
+    elif isinstance(concurrency, int):
+        semaphore = asyncio.Semaphore(concurrency)
+    else:
+        raise TypeError(concurrency)
+
+    async def limited_task(coro):
+        async with semaphore:
+            return await coro
+
+    tasks = [asyncio.create_task(limited_task(coro)) for coro in coros]
+    done, pending = await asyncio.wait(tasks, return_when=return_when)
+
+    for task in pending:
+        task.cancel()
+
+    for task in done:
+        if task.exception():
+            raise task.exception()  # type: ignore
+
+    return [task.result() for task in done]

omlish/asyncs/ioproxy/all.py

@@ -0,0 +1,32 @@
+from .io import (  # noqa
+    BufferedIOBase_AsyncIoProxy as BufferedIOBase,
+    BufferedRandom_AsyncIoProxy as BufferedRandom,
+    BufferedReader_AsyncIoProxy as BufferedReader,
+    BufferedRWPair_AsyncIoProxy as BufferedRWPair,
+    BufferedWriter_AsyncIoProxy as BufferedWriter,
+    BytesIO_AsyncIoProxy as BytesIO,
+    FileIO_AsyncIoProxy as FileIO,
+    IOBase_AsyncIoProxy as IOBase,
+    RawIOBase_AsyncIoProxy as RawIOBase,
+    StringIO_AsyncIoProxy as StringIO,
+    TextIOBase_AsyncIoProxy as TextIOBase,
+    TextIOWrapper_AsyncIoProxy as TextIOWrapper,
+)
+
+from .proxier import (  # noqa
+    AsyncIoProxier as Proxier,
+)
+
+from .proxy import (  # noqa
+    AsyncIoProxy as Proxy,
+    AsyncIoProxyRunner as Runer,
+    AsyncIoProxyTarget as Target,
+    async_io_proxy_cls_for as proxy_cls_for,
+    async_io_proxy_fn as proxy_fn,
+)
+
+from .typing import (  # noqa
+    TypingBinaryIO_AsyncIoProxy as TypingBinaryIO,
+    TypingIO_AsyncIoProxy as TypingIO,
+    TypingTextIO_AsyncIoProxy as TypingTextIO,
+)

omlish/asyncs/ioproxy/io.py

@@ -13,7 +13,7 @@ SelfT = ta.TypeVar('SelfT')
 
 
 @_register_async_io_proxy_cls
-class IOBaseAsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):
+class IOBase_AsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):  # noqa
     # https://github.com/python/cpython/blob/e65a1eb93ae35f9fbab1508606e3fbc89123629f/Lib/_pyio.py#L305
 
     ##
@@ -91,7 +91,7 @@ class IOBaseAsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):
 
 
 @_register_async_io_proxy_cls
-class RawIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.RawIOBase):
+class RawIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.RawIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -106,7 +106,7 @@ class RawIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.RawIOBase):
 
 
 @_register_async_io_proxy_cls
-class BufferedIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.BufferedIOBase):
+class BufferedIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.BufferedIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -126,7 +126,7 @@ class BufferedIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.BufferedIOBa
         raise TypeError
 
 
-class BufferedIOMixinAsyncIoProxy(BufferedIOBaseAsyncIoProxy):
+class BufferedIOMixin_AsyncIoProxy(BufferedIOBase_AsyncIoProxy):  # noqa
     @property
     def raw(self):
         raise TypeError
@@ -141,7 +141,7 @@ class BufferedIOMixinAsyncIoProxy(BufferedIOBaseAsyncIoProxy):
 
 
 @_register_async_io_proxy_cls
-class BytesIOAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BytesIO):
+class BytesIO_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BytesIO):  # noqa
     async def getvalue(self):
         raise TypeError
 
@@ -150,29 +150,29 @@ class BytesIOAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BytesIO):
 
 
 @_register_async_io_proxy_cls
-class BufferedReaderAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedReader):
+class BufferedReader_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedReader):  # noqa
     async def peek(self, size=0):
         raise TypeError
 
 
 @_register_async_io_proxy_cls
-class BufferedWriterAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedWriter):
+class BufferedWriter_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedWriter):  # noqa
     pass
 
 
 @_register_async_io_proxy_cls
-class BufferedRWPairAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BufferedRWPair):
+class BufferedRWPair_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BufferedRWPair):  # noqa
     async def peek(self, size=0):
         raise TypeError
 
 
 @_register_async_io_proxy_cls
-class BufferedRandomAsyncIoProxy(BufferedWriterAsyncIoProxy, BufferedReaderAsyncIoProxy, proxied_cls=io.BufferedRandom):
+class BufferedRandom_AsyncIoProxy(BufferedWriter_AsyncIoProxy, BufferedReader_AsyncIoProxy, proxied_cls=io.BufferedRandom):  # noqa
     pass
 
 
 @_register_async_io_proxy_cls
-class FileIOAsyncIoProxy(RawIOBaseAsyncIoProxy, proxied_cls=io.FileIO):
+class FileIO_AsyncIoProxy(RawIOBase_AsyncIoProxy, proxied_cls=io.FileIO):  # noqa
     @property
     def closefd(self):
         raise TypeError
@@ -183,7 +183,7 @@ class FileIOAsyncIoProxy(RawIOBaseAsyncIoProxy, proxied_cls=io.FileIO):
 
 
 @_register_async_io_proxy_cls
-class TextIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.TextIOBase):
+class TextIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.TextIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -207,7 +207,7 @@ class TextIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.TextIOBase):
 
 
 @_register_async_io_proxy_cls
-class TextIOWrapperAsyncIoProxy(TextIOBaseAsyncIoProxy, proxied_cls=io.TextIOWrapper):
+class TextIOWrapper_AsyncIoProxy(TextIOBase_AsyncIoProxy, proxied_cls=io.TextIOWrapper):  # noqa
     @property
     def line_buffering(self):
         raise TypeError
@@ -237,6 +237,6 @@ class TextIOWrapperAsyncIoProxy(TextIOBaseAsyncIoProxy, proxied_cls=io.TextIOWra
 
 
 @_register_async_io_proxy_cls
-class StringIOAsyncIoProxy(TextIOWrapperAsyncIoProxy, proxied_cls=io.StringIO):
+class StringIO_AsyncIoProxy(TextIOWrapper_AsyncIoProxy, proxied_cls=io.StringIO):  # noqa
     async def getvalue(self):
         raise TypeError

omlish/asyncs/ioproxy/proxier.py

@@ -3,25 +3,25 @@ import io
 import types
 import typing as ta
 
-from .io import BufferedIOBaseAsyncIoProxy
-from .io import BufferedRandomAsyncIoProxy
-from .io import BufferedReaderAsyncIoProxy
-from .io import BufferedRWPairAsyncIoProxy
-from .io import BufferedWriterAsyncIoProxy
-from .io import BytesIOAsyncIoProxy
-from .io import FileIOAsyncIoProxy
-from .io import IOBaseAsyncIoProxy
-from .io import RawIOBaseAsyncIoProxy
-from .io import StringIOAsyncIoProxy
-from .io import TextIOBaseAsyncIoProxy
-from .io import TextIOWrapperAsyncIoProxy
+from .io import BufferedIOBase_AsyncIoProxy
+from .io import BufferedRandom_AsyncIoProxy
+from .io import BufferedReader_AsyncIoProxy
+from .io import BufferedRWPair_AsyncIoProxy
+from .io import BufferedWriter_AsyncIoProxy
+from .io import BytesIO_AsyncIoProxy
+from .io import FileIO_AsyncIoProxy
+from .io import IOBase_AsyncIoProxy
+from .io import RawIOBase_AsyncIoProxy
+from .io import StringIO_AsyncIoProxy
+from .io import TextIOBase_AsyncIoProxy
+from .io import TextIOWrapper_AsyncIoProxy
 from .proxy import AsyncIoProxyRunner
 from .proxy import AsyncIoProxyTarget
 from .proxy import async_io_proxy_cls_for
 from .proxy import async_io_proxy_fn
-from .typing import TypingBinaryIOAsyncIoProxy
-from .typing import TypingIOAsyncIoProxy
-from .typing import TypingTextIOAsyncIoProxy
+from .typing import TypingBinaryIO_AsyncIoProxy
+from .typing import TypingIO_AsyncIoProxy
+from .typing import TypingTextIO_AsyncIoProxy
 
 
 ##
@@ -56,65 +56,65 @@ class AsyncIoProxier:
     ##
 
     @ta.overload
-    def proxy_obj(self, obj: io.StringIO) -> StringIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 1
+    def proxy_obj(self, obj: io.StringIO) -> StringIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 1
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapperAsyncIoProxy:  # type: ignore[overload-overlap]  # 2
+    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapper_AsyncIoProxy:  # type: ignore[overload-overlap]  # 2
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBaseAsyncIoProxy:  # 3
+    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBase_AsyncIoProxy:  # 3
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.FileIO) -> FileIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 4
+    def proxy_obj(self, obj: io.FileIO) -> FileIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 4
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandomAsyncIoProxy:  # type: ignore[overload-overlap]  # 5
+    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandom_AsyncIoProxy:  # type: ignore[overload-overlap]  # 5
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPairAsyncIoProxy:  # 6
+    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPair_AsyncIoProxy:  # 6
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriterAsyncIoProxy:  # type: ignore[overload-overlap]  # 7
+    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriter_AsyncIoProxy:  # type: ignore[overload-overlap]  # 7
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReaderAsyncIoProxy:  # type: ignore[overload-overlap]  # 8
+    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReader_AsyncIoProxy:  # type: ignore[overload-overlap]  # 8
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BytesIO) -> BytesIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 9
+    def proxy_obj(self, obj: io.BytesIO) -> BytesIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 9
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBaseAsyncIoProxy:  # 10
+    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBase_AsyncIoProxy:  # 10
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBaseAsyncIoProxy:  # 11
+    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBase_AsyncIoProxy:  # 11
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.IOBase) -> IOBaseAsyncIoProxy:  # 12
+    def proxy_obj(self, obj: io.IOBase) -> IOBase_AsyncIoProxy:  # 12
         ...
 
     #
 
     @ta.overload
-    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIOAsyncIoProxy:  # 13
+    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIO_AsyncIoProxy:  # 13
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIOAsyncIoProxy:  # 14
+    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIO_AsyncIoProxy:  # 14
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: ta.IO) -> TypingIOAsyncIoProxy:  # 15
+    def proxy_obj(self, obj: ta.IO) -> TypingIO_AsyncIoProxy:  # 15
         ...
 
     #

omlish/asyncs/ioproxy/typing.py

@@ -14,7 +14,7 @@ AnyStrT = ta.TypeVar('AnyStrT', bytes, str)
 
 
 @_register_async_io_proxy_cls
-class TypingIOAsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):
+class TypingIO_AsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):  # noqa
     @property
     def mode(self) -> str:
         raise TypeError
@@ -80,13 +80,13 @@ class TypingIOAsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO)
 
 
 @_register_async_io_proxy_cls
-class TypingBinaryIOAsyncIoProxy(TypingIOAsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):
+class TypingBinaryIO_AsyncIoProxy(TypingIO_AsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):  # noqa
     def write(self, s: ta.Union[bytes, bytearray]) -> int:  # type: ignore[override]
         raise TypeError
 
 
 @_register_async_io_proxy_cls
-class TypingTextIOAsyncIoProxy(TypingIOAsyncIoProxy[str], proxied_cls=ta.TextIO):
+class TypingTextIO_AsyncIoProxy(TypingIO_AsyncIoProxy[str], proxied_cls=ta.TextIO):  # noqa
     # @property
     # def buffer(self) -> BinaryIO:
     #     pass

omlish/formats/json/stream/lex.py

@@ -4,6 +4,7 @@ TODO:
  - max recursion depth
  - mark start pos of tokens, currently returning end
  - _do_string inner loop optimization somehow
+ - json5 mode
 """
 import dataclasses as dc
 import io

omlish/formats/json5/Json5.g4

@@ -0,0 +1,172 @@
+// Student Main
+// 2020-07-22
+// Public domain
+
+// JSON5 is a superset of JSON, it included some feature from ES5.1
+// See https://json5.org/
+// Derived from ../json/JSON.g4 which original derived from http://json.org
+
+// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
+
+grammar Json5;
+
+json5
+    : value? EOF
+    ;
+
+obj
+    : '{' pair (',' pair)* ','? '}'
+    | '{' '}'
+    ;
+
+pair
+    : key ':' value
+    ;
+
+key
+    : STRING
+    | IDENTIFIER
+    | LITERAL
+    | NUMERIC_LITERAL
+    ;
+
+value
+    : STRING
+    | number
+    | obj
+    | arr
+    | LITERAL
+    ;
+
+arr
+    : '[' value (',' value)* ','? ']'
+    | '[' ']'
+    ;
+
+number
+    : SYMBOL? (NUMERIC_LITERAL | NUMBER)
+    ;
+
+// Lexer
+
+SINGLE_LINE_COMMENT
+    : '//' .*? (NEWLINE | EOF) -> skip
+    ;
+
+MULTI_LINE_COMMENT
+    : '/*' .*? '*/' -> skip
+    ;
+
+LITERAL
+    : 'true'
+    | 'false'
+    | 'null'
+    ;
+
+STRING
+    : '"' DOUBLE_QUOTE_CHAR* '"'
+    | '\'' SINGLE_QUOTE_CHAR* '\''
+    ;
+
+fragment DOUBLE_QUOTE_CHAR
+    : ~["\\\r\n]
+    | ESCAPE_SEQUENCE
+    ;
+
+fragment SINGLE_QUOTE_CHAR
+    : ~['\\\r\n]
+    | ESCAPE_SEQUENCE
+    ;
+
+fragment ESCAPE_SEQUENCE
+    : '\\' (
+        NEWLINE
+        | UNICODE_SEQUENCE       // \u1234
+        | ['"\\/bfnrtv]          // single escape char
+        | ~['"\\bfnrtv0-9xu\r\n] // non escape char
+        | '0'                    // \0
+        | 'x' HEX HEX            // \x3a
+    )
+    ;
+
+NUMBER
+    : INT ('.' [0-9]*)? EXP? // +1.e2, 1234, 1234.5
+    | '.' [0-9]+ EXP?        // -.2e3
+    | '0' [xX] HEX+          // 0x12345678
+    ;
+
+NUMERIC_LITERAL
+    : 'Infinity'
+    | 'NaN'
+    ;
+
+SYMBOL
+    : '+'
+    | '-'
+    ;
+
+fragment HEX
+    : [0-9a-fA-F]
+    ;
+
+fragment INT
+    : '0'
+    | [1-9] [0-9]*
+    ;
+
+fragment EXP
+    : [Ee] SYMBOL? [0-9]*
+    ;
+
+IDENTIFIER
+    : IDENTIFIER_START IDENTIFIER_PART*
+    ;
+
+fragment IDENTIFIER_START
+    : [\p{L}]
+    | '$'
+    | '_'
+    | '\\' UNICODE_SEQUENCE
+    ;
+
+fragment IDENTIFIER_PART
+    : IDENTIFIER_START
+    | [\p{M}]
+    | [\p{N}]
+    | [\p{Pc}]
+    | '\u200C'
+    | '\u200D'
+    ;
+
+fragment UNICODE_SEQUENCE
+    : 'u' HEX HEX HEX HEX
+    ;
+
+fragment NEWLINE
+    : '\r\n'
+    | [\r\n\u2028\u2029]
+    ;
+
+fragment WS1
+    : '\u0009'
+    | '\u000A'
+    | '\u000B'
+    | '\u000C'
+    | '\u000D'
+    | '\u0020'
+    | '\u00A0'
+    | '\u2028'
+    | '\u2029'
+    | '\uFEFF'
+
+    | '\u1680'
+    | '\u2000' ..'\u200A'
+    | '\u202F'
+    | '\u205F'
+    | '\u3000'
+    ;
+
+WS
+    : WS1+ -> skip
+    ;

omlish/formats/json5/__init__.py

@@ -0,0 +1,8 @@
+from .codec import (  # noqa
+    dumps,
+    loads,
+)
+
+from .errors import (  # noqa
+    Json5Error,
+)