@g9tm/syncdata 1.2.1

package/dist/abstractions/guid.d.ts

@@ -0,0 +1,24 @@
+/** The nil GUID in canonical form. */
+export declare const EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
+/**
+ * Parses a GUID the way `Guid.TryParse` reads the forms G9SyncData meets — "D" (`8-4-4-4-12`), "N" (32 digits),
+ * "B" (`{D}`) and "P" (`(D)`), any case, surrounding white space ignored — and returns its 32 lower-case hex digits,
+ * or null. (The rare "X" form `{0x…,{0x…}}` is not accepted; PARITY.md.)
+ */
+export declare function guidDigits(text: string | null | undefined): string | null;
+/** Canonical text of a GUID (`Guid.Parse(text).ToString("D")`), or null when `text` is not a GUID. */
+export declare function tryNormalizeGuid(text: string | null | undefined): string | null;
+/** Canonical text of a GUID; throws `SyntaxError` (the .NET `FormatException`) when `text` is not one. */
+export declare function normalizeGuid(text: string): string;
+/** "N" form: 32 lower-case hex digits (`Guid.ToString("N")`). */
+export declare function guidToN(text: string): string;
+/** Writes the 16 big-endian bytes of a GUID. */
+export declare function writeGuidBytes(text: string, bytes: Uint8Array, offset: number): void;
+/** Canonical text of 16 big-endian GUID bytes. */
+export declare function readGuidBytes(bytes: Uint8Array, offset: number): string;
+/**
+ * A random (version 4) GUID in canonical form, the `Guid.NewGuid()` twin. Uses `crypto.getRandomValues` where the
+ * runtime has it (Lynx's background thread has no `crypto`; it falls back to `Math.random`, which is enough for ids that
+ * are unique, not secret).
+ */
+export declare function newGuid(): string;

package/dist/abstractions/guid.js

@@ -0,0 +1,93 @@
+// GUID text and bytes, the twins of the .NET forms G9SyncData uses: canonical text is lower-case "D"
+// (`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`, PostgreSQL's uuid::text), and the wire bytes are the big-endian (RFC 4122)
+// order of that text (`Guid.TryWriteBytes(bigEndian: true)`).
+const HEX_DIGIT = /^[0-9a-fA-F]{32}$/;
+/** The nil GUID in canonical form. */
+export const EMPTY_GUID = '00000000-0000-0000-0000-000000000000';
+/**
+ * Parses a GUID the way `Guid.TryParse` reads the forms G9SyncData meets — "D" (`8-4-4-4-12`), "N" (32 digits),
+ * "B" (`{D}`) and "P" (`(D)`), any case, surrounding white space ignored — and returns its 32 lower-case hex digits,
+ * or null. (The rare "X" form `{0x…,{0x…}}` is not accepted; PARITY.md.)
+ */
+export function guidDigits(text) {
+    if (typeof text !== 'string')
+        return null;
+    let s = text.trim();
+    if (s.length === 38 && ((s.charAt(0) === '{' && s.charAt(37) === '}') || (s.charAt(0) === '(' && s.charAt(37) === ')'))) {
+        s = s.slice(1, 37);
+    }
+    let digits;
+    if (s.length === 36) {
+        if (s.charAt(8) !== '-' || s.charAt(13) !== '-' || s.charAt(18) !== '-' || s.charAt(23) !== '-')
+            return null;
+        digits = s.slice(0, 8) + s.slice(9, 13) + s.slice(14, 18) + s.slice(19, 23) + s.slice(24);
+    }
+    else if (s.length === 32) {
+        digits = s;
+    }
+    else {
+        return null;
+    }
+    return HEX_DIGIT.test(digits) ? digits.toLowerCase() : null;
+}
+/** Canonical lower-case "D" text of 32 hex digits. */
+function formatDigits(digits) {
+    return digits.slice(0, 8) + '-' + digits.slice(8, 12) + '-' + digits.slice(12, 16) + '-' + digits.slice(16, 20) + '-' + digits.slice(20);
+}
+/** Canonical text of a GUID (`Guid.Parse(text).ToString("D")`), or null when `text` is not a GUID. */
+export function tryNormalizeGuid(text) {
+    const digits = guidDigits(text);
+    return digits === null ? null : formatDigits(digits);
+}
+/** Canonical text of a GUID; throws `SyntaxError` (the .NET `FormatException`) when `text` is not one. */
+export function normalizeGuid(text) {
+    const canonical = tryNormalizeGuid(text);
+    if (canonical === null)
+        throw new SyntaxError(`'${text}' is not a GUID.`);
+    return canonical;
+}
+/** "N" form: 32 lower-case hex digits (`Guid.ToString("N")`). */
+export function guidToN(text) {
+    const digits = guidDigits(text);
+    if (digits === null)
+        throw new SyntaxError(`'${text}' is not a GUID.`);
+    return digits;
+}
+/** Writes the 16 big-endian bytes of a GUID. */
+export function writeGuidBytes(text, bytes, offset) {
+    const digits = guidDigits(text);
+    if (digits === null)
+        throw new SyntaxError(`'${text}' is not a GUID.`);
+    for (let i = 0; i < 16; i++)
+        bytes[offset + i] = parseInt(digits.substr(i * 2, 2), 16);
+}
+const HEX = '0123456789abcdef';
+/** Canonical text of 16 big-endian GUID bytes. */
+export function readGuidBytes(bytes, offset) {
+    let digits = '';
+    for (let i = 0; i < 16; i++) {
+        const b = bytes[offset + i];
+        digits += HEX.charAt(b >> 4) + HEX.charAt(b & 15);
+    }
+    return formatDigits(digits);
+}
+/**
+ * A random (version 4) GUID in canonical form, the `Guid.NewGuid()` twin. Uses `crypto.getRandomValues` where the
+ * runtime has it (Lynx's background thread has no `crypto`; it falls back to `Math.random`, which is enough for ids that
+ * are unique, not secret).
+ */
+export function newGuid() {
+    const bytes = new Uint8Array(16);
+    const cryptoObject = globalThis.crypto;
+    if (cryptoObject && typeof cryptoObject.getRandomValues === 'function') {
+        cryptoObject.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return readGuidBytes(bytes, 0);
+}
+//# sourceMappingURL=guid.js.map

package/dist/abstractions/guid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guid.js","sourceRoot":"","sources":["../../src/abstractions/guid.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,sHAAsH;AACtH,8DAA8D;AAE9D,MAAM,SAAS,GAAG,mBAAmB,CAAC;AAEtC,sCAAsC;AACtC,MAAM,CAAC,MAAM,UAAU,GAAG,sCAAsC,CAAC;AAEjE;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAA+B;IACxD,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC1C,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IACpB,IAAI,CAAC,CAAC,MAAM,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;QACxH,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACrB,CAAC;IACD,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QACpB,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,GAAG;YAAE,OAAO,IAAI,CAAC;QAC7G,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5F,CAAC;SAAM,IAAI,CAAC,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QAC3B,MAAM,GAAG,CAAC,CAAC;IACb,CAAC;SAAM,CAAC;QACN,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC9D,CAAC;AAED,sDAAsD;AACtD,SAAS,YAAY,CAAC,MAAc;IAClC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC3I,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,gBAAgB,CAAC,IAA+B;IAC9D,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC;AAED,0GAA0G;AAC1G,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,SAAS,KAAK,IAAI;QAAE,MAAM,IAAI,WAAW,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC;IAC1E,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,OAAO,CAAC,IAAY;IAClC,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,MAAM,KAAK,IAAI;QAAE,MAAM,IAAI,WAAW,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC;IACvE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,KAAiB,EAAE,MAAc;IAC5E,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,MAAM,KAAK,IAAI;QAAE,MAAM,IAAI,WAAW,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC;IACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE;QAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACzF,CAAC;AAED,MAAM,GAAG,GAAG,kBAAkB,CAAC;AAE/B,kDAAkD;AAClD,MAAM,UAAU,aAAa,CAAC,KAAiB,EAAE,MAAc;IAC7D,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAW,CAAC;QACtC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO;IACrB,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,YAAY,GAAI,UAAmF,CAAC,MAAM,CAAC;IACjH,IAAI,YAAY,IAAI,OAAO,YAAY,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;QACvE,YAAY,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;SAAM,CAAC;QACN,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE;YAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IAC1E,CAAC;IACD,KAAK,CAAC,CAAC,CAAC,GAAG,CAAE,KAAK,CAAC,CAAC,CAAY,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,CAAC,CAAC,GAAG,CAAE,KAAK,CAAC,CAAC,CAAY,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IAChD,OAAO,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACjC,CAAC","sourcesContent":["// GUID text and bytes, the twins of the .NET forms G9SyncData uses: canonical text is lower-case \"D\"\n// (`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`, PostgreSQL's uuid::text), and the wire bytes are the big-endian (RFC 4122)\n// order of that text (`Guid.TryWriteBytes(bigEndian: true)`).\n\nconst HEX_DIGIT = /^[0-9a-fA-F]{32}$/;\n\n/** The nil GUID in canonical form. */\nexport const EMPTY_GUID = '00000000-0000-0000-0000-000000000000';\n\n/**\n * Parses a GUID the way `Guid.TryParse` reads the forms G9SyncData meets — \"D\" (`8-4-4-4-12`), \"N\" (32 digits),\n * \"B\" (`{D}`) and \"P\" (`(D)`), any case, surrounding white space ignored — and returns its 32 lower-case hex digits,\n * or null. (The rare \"X\" form `{0x…,{0x…}}` is not accepted; PARITY.md.)\n */\nexport function guidDigits(text: string | null | undefined): string | null {\n  if (typeof text !== 'string') return null;\n  let s = text.trim();\n  if (s.length === 38 && ((s.charAt(0) === '{' && s.charAt(37) === '}') || (s.charAt(0) === '(' && s.charAt(37) === ')'))) {\n    s = s.slice(1, 37);\n  }\n  let digits: string;\n  if (s.length === 36) {\n    if (s.charAt(8) !== '-' || s.charAt(13) !== '-' || s.charAt(18) !== '-' || s.charAt(23) !== '-') return null;\n    digits = s.slice(0, 8) + s.slice(9, 13) + s.slice(14, 18) + s.slice(19, 23) + s.slice(24);\n  } else if (s.length === 32) {\n    digits = s;\n  } else {\n    return null;\n  }\n  return HEX_DIGIT.test(digits) ? digits.toLowerCase() : null;\n}\n\n/** Canonical lower-case \"D\" text of 32 hex digits. */\nfunction formatDigits(digits: string): string {\n  return digits.slice(0, 8) + '-' + digits.slice(8, 12) + '-' + digits.slice(12, 16) + '-' + digits.slice(16, 20) + '-' + digits.slice(20);\n}\n\n/** Canonical text of a GUID (`Guid.Parse(text).ToString(\"D\")`), or null when `text` is not a GUID. */\nexport function tryNormalizeGuid(text: string | null | undefined): string | null {\n  const digits = guidDigits(text);\n  return digits === null ? null : formatDigits(digits);\n}\n\n/** Canonical text of a GUID; throws `SyntaxError` (the .NET `FormatException`) when `text` is not one. */\nexport function normalizeGuid(text: string): string {\n  const canonical = tryNormalizeGuid(text);\n  if (canonical === null) throw new SyntaxError(`'${text}' is not a GUID.`);\n  return canonical;\n}\n\n/** \"N\" form: 32 lower-case hex digits (`Guid.ToString(\"N\")`). */\nexport function guidToN(text: string): string {\n  const digits = guidDigits(text);\n  if (digits === null) throw new SyntaxError(`'${text}' is not a GUID.`);\n  return digits;\n}\n\n/** Writes the 16 big-endian bytes of a GUID. */\nexport function writeGuidBytes(text: string, bytes: Uint8Array, offset: number): void {\n  const digits = guidDigits(text);\n  if (digits === null) throw new SyntaxError(`'${text}' is not a GUID.`);\n  for (let i = 0; i < 16; i++) bytes[offset + i] = parseInt(digits.substr(i * 2, 2), 16);\n}\n\nconst HEX = '0123456789abcdef';\n\n/** Canonical text of 16 big-endian GUID bytes. */\nexport function readGuidBytes(bytes: Uint8Array, offset: number): string {\n  let digits = '';\n  for (let i = 0; i < 16; i++) {\n    const b = bytes[offset + i] as number;\n    digits += HEX.charAt(b >> 4) + HEX.charAt(b & 15);\n  }\n  return formatDigits(digits);\n}\n\n/**\n * A random (version 4) GUID in canonical form, the `Guid.NewGuid()` twin. Uses `crypto.getRandomValues` where the\n * runtime has it (Lynx's background thread has no `crypto`; it falls back to `Math.random`, which is enough for ids that\n * are unique, not secret).\n */\nexport function newGuid(): string {\n  const bytes = new Uint8Array(16);\n  const cryptoObject = (globalThis as { crypto?: { getRandomValues?: (array: Uint8Array) => Uint8Array } }).crypto;\n  if (cryptoObject && typeof cryptoObject.getRandomValues === 'function') {\n    cryptoObject.getRandomValues(bytes);\n  } else {\n    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);\n  }\n  bytes[6] = ((bytes[6] as number) & 0x0f) | 0x40;\n  bytes[8] = ((bytes[8] as number) & 0x3f) | 0x80;\n  return readGuidBytes(bytes, 0);\n}\n"]}

package/dist/abstractions/key.d.ts

@@ -0,0 +1,16 @@
+import { G9Long } from './long.js';
+/**
+ * Canonical primary-key text (twin of `G9CSyncKey`). Every place a key is compared, hashed or stored as text uses this
+ * form, so the same row can never appear under two spellings. v1 supports single-column keys of type Guid, String,
+ * Int32 and Int64 (ADR-0006).
+ */
+export declare const G9SyncKey: {
+    /** True when `type` can be a primary key. */
+    isSupportedKeyType(type: number): boolean;
+    /** Canonical text of an integer key (invariant decimal, PostgreSQL `bigint::text`). */
+    fromInt64(value: number | G9Long): string;
+    /** Normalises a textual key of the given type to canonical form; throws `SyntaxError` (FormatException) when invalid. */
+    normalize(keyType: number, key: string): string;
+    /** Tries to normalise; null instead of throwing. */
+    tryNormalize(keyType: number, key: string | null | undefined): string | null;
+};

package/dist/abstractions/key.js

@@ -0,0 +1,47 @@
+import { G9ESyncColumnType } from './enums.js';
+import { tryNormalizeGuid } from './guid.js';
+import { G9Long } from './long.js';
+/**
+ * Canonical primary-key text (twin of `G9CSyncKey`). Every place a key is compared, hashed or stored as text uses this
+ * form, so the same row can never appear under two spellings. v1 supports single-column keys of type Guid, String,
+ * Int32 and Int64 (ADR-0006).
+ */
+export const G9SyncKey = {
+    /** True when `type` can be a primary key. */
+    isSupportedKeyType(type) {
+        return type === G9ESyncColumnType.Guid || type === G9ESyncColumnType.String || type === G9ESyncColumnType.Int32 || type === G9ESyncColumnType.Int64;
+    },
+    /** Canonical text of an integer key (invariant decimal, PostgreSQL `bigint::text`). */
+    fromInt64(value) {
+        return value instanceof G9Long ? value.toString() : G9Long.fromNumber(value).toString();
+    },
+    /** Normalises a textual key of the given type to canonical form; throws `SyntaxError` (FormatException) when invalid. */
+    normalize(keyType, key) {
+        const canonical = G9SyncKey.tryNormalize(keyType, key);
+        if (canonical === null) {
+            if (!G9SyncKey.isSupportedKeyType(keyType))
+                throw new RangeError(`Unsupported key type ${keyType}.`);
+            throw new SyntaxError(`'${key}' is not a valid key of type ${keyType}.`);
+        }
+        return canonical;
+    },
+    /** Tries to normalise; null instead of throwing. */
+    tryNormalize(keyType, key) {
+        if (typeof key !== 'string')
+            return null;
+        switch (keyType) {
+            case G9ESyncColumnType.Guid:
+                return tryNormalizeGuid(key);
+            case G9ESyncColumnType.Int32:
+            case G9ESyncColumnType.Int64: {
+                const parsed = G9Long.tryParse(key);
+                return parsed === null ? null : parsed.toString();
+            }
+            case G9ESyncColumnType.String:
+                return key;
+            default:
+                return null;
+        }
+    },
+};
+//# sourceMappingURL=key.js.map

package/dist/abstractions/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/abstractions/key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,6CAA6C;IAC7C,kBAAkB,CAAC,IAAY;QAC7B,OAAO,IAAI,KAAK,iBAAiB,CAAC,IAAI,IAAI,IAAI,KAAK,iBAAiB,CAAC,MAAM,IAAI,IAAI,KAAK,iBAAiB,CAAC,KAAK,IAAI,IAAI,KAAK,iBAAiB,CAAC,KAAK,CAAC;IACtJ,CAAC;IAED,uFAAuF;IACvF,SAAS,CAAC,KAAsB;QAC9B,OAAO,KAAK,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1F,CAAC;IAED,yHAAyH;IACzH,SAAS,CAAC,OAAe,EAAE,GAAW;QACpC,MAAM,SAAS,GAAG,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QACvD,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,OAAO,CAAC;gBAAE,MAAM,IAAI,UAAU,CAAC,wBAAwB,OAAO,GAAG,CAAC,CAAC;YACrG,MAAM,IAAI,WAAW,CAAC,IAAI,GAAG,gCAAgC,OAAO,GAAG,CAAC,CAAC;QAC3E,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,oDAAoD;IACpD,YAAY,CAAC,OAAe,EAAE,GAA8B;QAC1D,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;QACzC,QAAQ,OAAO,EAAE,CAAC;YAChB,KAAK,iBAAiB,CAAC,IAAI;gBACzB,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC/B,KAAK,iBAAiB,CAAC,KAAK,CAAC;YAC7B,KAAK,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBACpC,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpD,CAAC;YACD,KAAK,iBAAiB,CAAC,MAAM;gBAC3B,OAAO,GAAG,CAAC;YACb;gBACE,OAAO,IAAI,CAAC;QAChB,CAAC;IACH,CAAC;CACF,CAAC","sourcesContent":["import { G9ESyncColumnType } from './enums.js';\nimport { tryNormalizeGuid } from './guid.js';\nimport { G9Long } from './long.js';\n\n/**\n * Canonical primary-key text (twin of `G9CSyncKey`). Every place a key is compared, hashed or stored as text uses this\n * form, so the same row can never appear under two spellings. v1 supports single-column keys of type Guid, String,\n * Int32 and Int64 (ADR-0006).\n */\nexport const G9SyncKey = {\n  /** True when `type` can be a primary key. */\n  isSupportedKeyType(type: number): boolean {\n    return type === G9ESyncColumnType.Guid || type === G9ESyncColumnType.String || type === G9ESyncColumnType.Int32 || type === G9ESyncColumnType.Int64;\n  },\n\n  /** Canonical text of an integer key (invariant decimal, PostgreSQL `bigint::text`). */\n  fromInt64(value: number | G9Long): string {\n    return value instanceof G9Long ? value.toString() : G9Long.fromNumber(value).toString();\n  },\n\n  /** Normalises a textual key of the given type to canonical form; throws `SyntaxError` (FormatException) when invalid. */\n  normalize(keyType: number, key: string): string {\n    const canonical = G9SyncKey.tryNormalize(keyType, key);\n    if (canonical === null) {\n      if (!G9SyncKey.isSupportedKeyType(keyType)) throw new RangeError(`Unsupported key type ${keyType}.`);\n      throw new SyntaxError(`'${key}' is not a valid key of type ${keyType}.`);\n    }\n    return canonical;\n  },\n\n  /** Tries to normalise; null instead of throwing. */\n  tryNormalize(keyType: number, key: string | null | undefined): string | null {\n    if (typeof key !== 'string') return null;\n    switch (keyType) {\n      case G9ESyncColumnType.Guid:\n        return tryNormalizeGuid(key);\n      case G9ESyncColumnType.Int32:\n      case G9ESyncColumnType.Int64: {\n        const parsed = G9Long.tryParse(key);\n        return parsed === null ? null : parsed.toString();\n      }\n      case G9ESyncColumnType.String:\n        return key;\n      default:\n        return null;\n    }\n  },\n};\n"]}

package/dist/abstractions/long.d.ts

@@ -0,0 +1,103 @@
+/**
+ * An exact signed 64-bit integer without BigInt (Lynx's PrimJS does not guarantee it): two 32-bit halves, `hi` signed
+ * and `lo` unsigned. It is the twin of .NET `long` wherever a value may exceed ±(2^53 − 1) and must stay exact:
+ * reconciliation digests and row hashes, dirty masks (up to 62 bits), DateTime ticks, int64 column values.
+ *
+ * Everything else in the protocol that .NET types as `long` (versions, batch ids, row counts, byte counts) is a plain
+ * `number` in TypeScript: those values are far below 2^53 in practice.
+ */
+export declare class G9Long {
+    /** High 32 bits, signed (two's complement). */
+    readonly hi: number;
+    /** Low 32 bits, unsigned. */
+    readonly lo: number;
+    constructor(hi: number, lo: number);
+    static readonly ZERO: G9Long;
+    static readonly ONE: G9Long;
+    static readonly MINUS_ONE: G9Long;
+    static readonly MIN_VALUE: G9Long;
+    static readonly MAX_VALUE: G9Long;
+    /** From any integer `number`. Exact for safe integers; larger magnitudes are taken from the double as it is. */
+    static fromNumber(value: number): G9Long;
+    /** From the two halves (hi signed or unsigned, lo unsigned or signed: both are normalised). */
+    static fromBits(hi: number, lo: number): G9Long;
+    /**
+     * Parses invariant decimal text (optional sign, digits only, no white space), the .NET
+     * `long.Parse(s, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture)` twin. Throws `RangeError` for anything
+     * else or a value outside the int64 range.
+     */
+    static parse(text: string): G9Long;
+    /** {@link parse} that returns null instead of throwing. */
+    static tryParse(text: string | null | undefined): G9Long | null;
+    /** Coerces a number, decimal text or G9Long. */
+    static from(value: G9Long | number | string | {
+        int64: string;
+    }): G9Long;
+    /** Reads 8 little-endian bytes. */
+    static readLE(bytes: Uint8Array, offset: number): G9Long;
+    /** Reads 8 big-endian bytes. */
+    static readBE(bytes: Uint8Array, offset: number): G9Long;
+    /** Writes 8 little-endian bytes. */
+    writeLE(bytes: Uint8Array, offset: number): void;
+    isZero(): boolean;
+    isNegative(): boolean;
+    /** True when the value lies within ±(2^53 − 1), i.e. {@link toNumber} is exact. */
+    isSafe(): boolean;
+    /** The value as a number: exact when {@link isSafe}, the nearest double otherwise. */
+    toNumber(): number;
+    equals(other: G9Long): boolean;
+    /** Signed comparison: negative, zero or positive. */
+    compare(other: G9Long): number;
+    negate(): G9Long;
+    not(): G9Long;
+    and(other: G9Long): G9Long;
+    or(other: G9Long): G9Long;
+    xor(other: G9Long): G9Long;
+    /** Wrapping addition (two's complement), like unchecked C#. */
+    add(other: G9Long): G9Long;
+    subtract(other: G9Long): G9Long;
+    /** Wrapping multiplication by a small non-negative integer (< 2^21). */
+    multiplySmall(factor: number): G9Long;
+    /** Shift left (C# `<<` with the count masked to 0..63). */
+    shiftLeft(count: number): G9Long;
+    /** Arithmetic shift right (C# `>>` on long). */
+    shiftRight(count: number): G9Long;
+    /** Logical shift right (C# `>>>` / ulong `>>`). */
+    shiftRightUnsigned(count: number): G9Long;
+    /** True when bit `index` (0..63) is set. */
+    testBit(index: number): boolean;
+    /**
+     * Divides the value as UNSIGNED 64 bits by a small divisor (1..2^21) and returns quotient and remainder. Used for
+     * decimal formatting and tick arithmetic.
+     */
+    divModUnsignedSmall(divisor: number): {
+        quotient: G9Long;
+        remainder: number;
+    };
+    /** Invariant decimal text, the .NET `long.ToString(CultureInfo.InvariantCulture)` twin. */
+    toString(): string;
+    /** The value as UNSIGNED decimal text (C# `ulong`). */
+    toUnsignedString(): string;
+    /**
+     * JSON form: a sentinel string that {@link stringifyJson} turns into a bare JSON number, so `JSON.stringify` of a DTO
+     * holding a G9Long writes the exact integer.
+     */
+    toJSON(): string;
+    /** The SQLite driver form (G9LynxControls `G9SqlValue`): a number when safe, `{ int64 }` otherwise. */
+    toSqlValue(): number | {
+        int64: string;
+    };
+}
+/** Marks a G9Long inside `JSON.stringify` output (a NUL, so no ordinary text produces it). */
+export declare const LONG_SENTINEL = "\0g9long:";
+/** `JSON.stringify` that writes every {@link G9Long} as an exact JSON number. */
+export declare function stringifyJson(value: unknown): string;
+/** Turns the G9Long sentinels in `JSON.stringify` output (G9Long.toJSON) into bare JSON numbers. */
+export declare function replaceLongSentinels(text: string): string;
+/**
+ * `JSON.parse` that keeps integers outside ±(2^53 − 1) exact: they come back as {@link G9Long} instead of a rounded
+ * number. Text without such an integer takes the plain `JSON.parse` path.
+ */
+export declare function parseJson(text: string): unknown;
+/** A protocol `long` read as a number (exact when it fits; a G9Long rounds to the nearest double). */
+export declare function longToNumber(value: unknown): number;

package/dist/abstractions/long.js

@@ -0,0 +1,351 @@
+/**
+ * An exact signed 64-bit integer without BigInt (Lynx's PrimJS does not guarantee it): two 32-bit halves, `hi` signed
+ * and `lo` unsigned. It is the twin of .NET `long` wherever a value may exceed ±(2^53 − 1) and must stay exact:
+ * reconciliation digests and row hashes, dirty masks (up to 62 bits), DateTime ticks, int64 column values.
+ *
+ * Everything else in the protocol that .NET types as `long` (versions, batch ids, row counts, byte counts) is a plain
+ * `number` in TypeScript: those values are far below 2^53 in practice.
+ */
+export class G9Long {
+    constructor(hi, lo) {
+        this.hi = hi | 0;
+        this.lo = lo >>> 0;
+    }
+    /** From any integer `number`. Exact for safe integers; larger magnitudes are taken from the double as it is. */
+    static fromNumber(value) {
+        if (!isFinite(value) || Math.floor(value) !== value)
+            throw new RangeError(`${value} is not an integer.`);
+        if (value >= 9223372036854775807)
+            return G9Long.MAX_VALUE;
+        if (value <= -9223372036854775808)
+            return G9Long.MIN_VALUE;
+        if (value < 0)
+            return G9Long.fromNumber(-value).negate();
+        const hi = Math.floor(value / TWO_32);
+        return new G9Long(hi, value - hi * TWO_32);
+    }
+    /** From the two halves (hi signed or unsigned, lo unsigned or signed: both are normalised). */
+    static fromBits(hi, lo) {
+        return new G9Long(hi, lo);
+    }
+    /**
+     * Parses invariant decimal text (optional sign, digits only, no white space), the .NET
+     * `long.Parse(s, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture)` twin. Throws `RangeError` for anything
+     * else or a value outside the int64 range.
+     */
+    static parse(text) {
+        const parsed = G9Long.tryParse(text);
+        if (!parsed)
+            throw new RangeError(`'${text}' is not a 64-bit integer.`);
+        return parsed;
+    }
+    /** {@link parse} that returns null instead of throwing. */
+    static tryParse(text) {
+        if (typeof text !== 'string')
+            return null;
+        const m = /^([+-]?)(\d+)$/.exec(text);
+        if (!m)
+            return null;
+        const negative = m[1] === '-';
+        const digits = m[2];
+        // Four 16-bit limbs, little-endian; value = value * 10 + digit, failing past 2^64.
+        const limbs = [0, 0, 0, 0];
+        for (let i = 0; i < digits.length; i++) {
+            let carry = digits.charCodeAt(i) - 48;
+            for (let k = 0; k < 4; k++) {
+                const v = limbs[k] * 10 + carry;
+                limbs[k] = v & 0xffff;
+                carry = Math.floor(v / 65536);
+            }
+            if (carry !== 0)
+                return null;
+        }
+        const hiU = (limbs[3] * 65536 + limbs[2]) >>> 0;
+        const lo = (limbs[1] * 65536 + limbs[0]) >>> 0;
+        // Range: magnitude ≤ 2^63 − 1, or exactly 2^63 when negative.
+        if (hiU > 0x7fffffff) {
+            if (!(negative && hiU === 0x80000000 && lo === 0))
+                return null;
+            return G9Long.MIN_VALUE;
+        }
+        const magnitude = new G9Long(hiU, lo);
+        return negative ? magnitude.negate() : magnitude;
+    }
+    /** Coerces a number, decimal text or G9Long. */
+    static from(value) {
+        if (value instanceof G9Long)
+            return value;
+        if (typeof value === 'number')
+            return G9Long.fromNumber(value);
+        if (typeof value === 'string')
+            return G9Long.parse(value);
+        if (value && typeof value === 'object' && typeof value.int64 === 'string') {
+            return G9Long.parse(value.int64);
+        }
+        throw new TypeError('Not a 64-bit integer.');
+    }
+    /** Reads 8 little-endian bytes. */
+    static readLE(bytes, offset) {
+        const lo = bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24);
+        const hi = bytes[offset + 4] | (bytes[offset + 5] << 8) | (bytes[offset + 6] << 16) | (bytes[offset + 7] << 24);
+        return new G9Long(hi, lo);
+    }
+    /** Reads 8 big-endian bytes. */
+    static readBE(bytes, offset) {
+        const hi = (bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3];
+        const lo = (bytes[offset + 4] << 24) | (bytes[offset + 5] << 16) | (bytes[offset + 6] << 8) | bytes[offset + 7];
+        return new G9Long(hi, lo);
+    }
+    /** Writes 8 little-endian bytes. */
+    writeLE(bytes, offset) {
+        const lo = this.lo;
+        const hi = this.hi;
+        bytes[offset] = lo & 0xff;
+        bytes[offset + 1] = (lo >>> 8) & 0xff;
+        bytes[offset + 2] = (lo >>> 16) & 0xff;
+        bytes[offset + 3] = (lo >>> 24) & 0xff;
+        bytes[offset + 4] = hi & 0xff;
+        bytes[offset + 5] = (hi >>> 8) & 0xff;
+        bytes[offset + 6] = (hi >>> 16) & 0xff;
+        bytes[offset + 7] = (hi >>> 24) & 0xff;
+    }
+    isZero() {
+        return this.hi === 0 && this.lo === 0;
+    }
+    isNegative() {
+        return this.hi < 0;
+    }
+    /** True when the value lies within ±(2^53 − 1), i.e. {@link toNumber} is exact. */
+    isSafe() {
+        const hi = this.hi;
+        if (hi >= 0)
+            return hi < 0x200000;
+        // -2^53 < v  ⇔  hi > -0x200000, or hi == -0x200000 and lo > 0.
+        return hi > -0x200000 || (hi === -0x200000 && this.lo > 0);
+    }
+    /** The value as a number: exact when {@link isSafe}, the nearest double otherwise. */
+    toNumber() {
+        return this.hi * TWO_32 + this.lo;
+    }
+    equals(other) {
+        return this.hi === other.hi && this.lo === other.lo;
+    }
+    /** Signed comparison: negative, zero or positive. */
+    compare(other) {
+        if (this.hi !== other.hi)
+            return this.hi < other.hi ? -1 : 1;
+        if (this.lo !== other.lo)
+            return this.lo < other.lo ? -1 : 1;
+        return 0;
+    }
+    negate() {
+        return this.not().add(G9Long.ONE);
+    }
+    not() {
+        return new G9Long(~this.hi, ~this.lo);
+    }
+    and(other) {
+        return new G9Long(this.hi & other.hi, this.lo & other.lo);
+    }
+    or(other) {
+        return new G9Long(this.hi | other.hi, this.lo | other.lo);
+    }
+    xor(other) {
+        return new G9Long(this.hi ^ other.hi, this.lo ^ other.lo);
+    }
+    /** Wrapping addition (two's complement), like unchecked C#. */
+    add(other) {
+        const lo = this.lo + other.lo;
+        const carry = lo >= TWO_32 ? 1 : 0;
+        return new G9Long((this.hi + other.hi + carry) | 0, lo >>> 0);
+    }
+    subtract(other) {
+        return this.add(other.negate());
+    }
+    /** Wrapping multiplication by a small non-negative integer (< 2^21). */
+    multiplySmall(factor) {
+        // 16-bit limbs keep every partial product below 2^37.
+        const l0 = (this.lo & 0xffff) * factor;
+        const l1 = (this.lo >>> 16) * factor + Math.floor(l0 / 65536);
+        const l2 = (this.hi & 0xffff) * factor + Math.floor(l1 / 65536);
+        const l3 = (this.hi >>> 16) * factor + Math.floor(l2 / 65536);
+        return new G9Long(((l3 & 0xffff) << 16) | (l2 & 0xffff), ((l1 & 0xffff) << 16) | (l0 & 0xffff));
+    }
+    /** Shift left (C# `<<` with the count masked to 0..63). */
+    shiftLeft(count) {
+        const n = count & 63;
+        if (n === 0)
+            return this;
+        if (n >= 32)
+            return new G9Long(this.lo << (n - 32), 0);
+        return new G9Long((this.hi << n) | (this.lo >>> (32 - n)), this.lo << n);
+    }
+    /** Arithmetic shift right (C# `>>` on long). */
+    shiftRight(count) {
+        const n = count & 63;
+        if (n === 0)
+            return this;
+        if (n >= 32)
+            return new G9Long(this.hi >> 31, this.hi >> (n - 32));
+        return new G9Long(this.hi >> n, (this.lo >>> n) | (this.hi << (32 - n)));
+    }
+    /** Logical shift right (C# `>>>` / ulong `>>`). */
+    shiftRightUnsigned(count) {
+        const n = count & 63;
+        if (n === 0)
+            return this;
+        if (n >= 32)
+            return new G9Long(0, this.hi >>> (n - 32));
+        return new G9Long(this.hi >>> n, (this.lo >>> n) | (this.hi << (32 - n)));
+    }
+    /** True when bit `index` (0..63) is set. */
+    testBit(index) {
+        return index >= 32 ? ((this.hi >>> (index - 32)) & 1) !== 0 : ((this.lo >>> index) & 1) !== 0;
+    }
+    /**
+     * Divides the value as UNSIGNED 64 bits by a small divisor (1..2^21) and returns quotient and remainder. Used for
+     * decimal formatting and tick arithmetic.
+     */
+    divModUnsignedSmall(divisor) {
+        const limbs = [this.hi >>> 16, this.hi & 0xffff, this.lo >>> 16, this.lo & 0xffff];
+        let remainder = 0;
+        for (let i = 0; i < 4; i++) {
+            const value = remainder * 65536 + limbs[i];
+            limbs[i] = Math.floor(value / divisor);
+            remainder = value - limbs[i] * divisor;
+        }
+        return {
+            quotient: new G9Long(((limbs[0] << 16) | limbs[1]) >>> 0, ((limbs[2] << 16) | limbs[3]) >>> 0),
+            remainder,
+        };
+    }
+    /** Invariant decimal text, the .NET `long.ToString(CultureInfo.InvariantCulture)` twin. */
+    toString() {
+        if (this.isSafe())
+            return String(this.toNumber());
+        if (this.equals(G9Long.MIN_VALUE))
+            return '-9223372036854775808';
+        const negative = this.isNegative();
+        let magnitude = negative ? this.negate() : this;
+        let out = '';
+        while (!magnitude.isZero()) {
+            const { quotient, remainder } = magnitude.divModUnsignedSmall(10000000);
+            magnitude = quotient;
+            const chunk = String(remainder);
+            out = (magnitude.isZero() ? chunk : '0000000'.slice(chunk.length) + chunk) + out;
+        }
+        return negative ? '-' + out : out;
+    }
+    /** The value as UNSIGNED decimal text (C# `ulong`). */
+    toUnsignedString() {
+        if (!this.isNegative())
+            return this.toString();
+        let magnitude = this;
+        let out = '';
+        while (!magnitude.isZero()) {
+            const { quotient, remainder } = magnitude.divModUnsignedSmall(10000000);
+            magnitude = quotient;
+            const chunk = String(remainder);
+            out = (magnitude.isZero() ? chunk : '0000000'.slice(chunk.length) + chunk) + out;
+        }
+        return out;
+    }
+    /**
+     * JSON form: a sentinel string that {@link stringifyJson} turns into a bare JSON number, so `JSON.stringify` of a DTO
+     * holding a G9Long writes the exact integer.
+     */
+    toJSON() {
+        return LONG_SENTINEL + this.toString();
+    }
+    /** The SQLite driver form (G9LynxControls `G9SqlValue`): a number when safe, `{ int64 }` otherwise. */
+    toSqlValue() {
+        return this.isSafe() ? this.toNumber() : { int64: this.toString() };
+    }
+}
+G9Long.ZERO = new G9Long(0, 0);
+G9Long.ONE = new G9Long(0, 1);
+G9Long.MINUS_ONE = new G9Long(-1, 0xffffffff);
+G9Long.MIN_VALUE = new G9Long(0x80000000 | 0, 0);
+G9Long.MAX_VALUE = new G9Long(0x7fffffff, 0xffffffff);
+const TWO_32 = 4294967296;
+/** Marks a G9Long inside `JSON.stringify` output (a NUL, so no ordinary text produces it). */
+export const LONG_SENTINEL = '\u0000g9long:';
+const LONG_SENTINEL_JSON = /"\\u0000g9long:(-?\d+)"/g;
+/** `JSON.stringify` that writes every {@link G9Long} as an exact JSON number. */
+export function stringifyJson(value) {
+    return replaceLongSentinels(JSON.stringify(value));
+}
+/** Turns the G9Long sentinels in `JSON.stringify` output (G9Long.toJSON) into bare JSON numbers. */
+export function replaceLongSentinels(text) {
+    return text.indexOf('\\u0000g9long:') < 0 ? text : text.replace(LONG_SENTINEL_JSON, '$1');
+}
+/**
+ * `JSON.parse` that keeps integers outside ±(2^53 − 1) exact: they come back as {@link G9Long} instead of a rounded
+ * number. Text without such an integer takes the plain `JSON.parse` path.
+ */
+export function parseJson(text) {
+    if (!/\d{16}/.test(text))
+        return JSON.parse(text);
+    // Quote the long integer literals OUTSIDE strings, tagged, then let JSON.parse do the rest.
+    let out = '';
+    let last = 0;
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        const c = text.charCodeAt(i);
+        if (c === 34) {
+            // Skip a string, honouring escapes.
+            i++;
+            while (i < n) {
+                const d = text.charCodeAt(i);
+                if (d === 92)
+                    i += 2;
+                else if (d === 34)
+                    break;
+                else
+                    i++;
+            }
+            i++;
+            continue;
+        }
+        if (c === 45 || (c >= 48 && c <= 57)) {
+            const start = i;
+            i++;
+            while (i < n) {
+                const d = text.charCodeAt(i);
+                if ((d >= 48 && d <= 57) || d === 46 || d === 101 || d === 69 || d === 43 || d === 45)
+                    i++;
+                else
+                    break;
+            }
+            const literal = text.slice(start, i);
+            if (/^-?\d{16,}$/.test(literal)) {
+                const parsed = G9Long.tryParse(literal);
+                if (parsed && !parsed.isSafe()) {
+                    // An escaped U+0001 in the JSON text: JSON.parse turns it into the tag the reviver looks for.
+                    out += text.slice(last, start) + '"\\u0001g9long:' + literal + '"';
+                    last = i;
+                }
+            }
+            continue;
+        }
+        i++;
+    }
+    if (last === 0)
+        return JSON.parse(text);
+    out += text.slice(last);
+    return JSON.parse(out, (_key, value) => typeof value === 'string' && value.indexOf(LONG_SENTINEL_TEXT) === 0 ? G9Long.parse(value.slice(LONG_SENTINEL_TEXT.length)) : value);
+}
+/** The tag parseJson puts in front of a long literal (a code point no JSON integer literal contains). */
+const LONG_SENTINEL_TEXT = '\u0001g9long:';
+/** A protocol `long` read as a number (exact when it fits; a G9Long rounds to the nearest double). */
+export function longToNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (value instanceof G9Long)
+        return value.toNumber();
+    if (typeof value === 'string' && value !== '')
+        return Number(value);
+    return 0;
+}
+//# sourceMappingURL=long.js.map