links-notation 0.21.3 → 0.23.0

package/index.d.ts

@@ -106,6 +106,12 @@ export class Link {
 /**
  * Parser options for configuring the parser behavior
  */
+/**
+ * How deep links may nest when nothing says otherwise (64). The same limit
+ * applies in every Links Notation implementation.
+ */
+export const DEFAULT_MAX_DEPTH: number;
+
 export interface ParserOptions {
   /**
    * Maximum input size in bytes (default: 10MB)
@@ -113,7 +119,9 @@ export interface ParserOptions {
   maxInputSize?: number;
 
   /**
-   * Maximum nesting depth (default: 1000)
+   * How deep links may nest: every parenthesized group and every indentation
+   * level is one level. A document nested deeper is refused with a ParseError
+   * whose maxDepth is set (default: 64)
    */
   maxDepth?: number;
 
@@ -293,6 +301,12 @@ export class ParseError extends Error {
    * The position the generated parser reported
    */
   location: ParseErrorLocation;
+
+  /**
+   * The deepest nesting allowed, when the document is nested deeper than
+   * that; null for any other error
+   */
+  maxDepth: number | null;
 }
 
 /**
@@ -456,3 +470,94 @@ export function formatLinks(
   links: Link[],
   lessParentheses?: boolean | FormatOptions | FormatConfig
 ): string;
+
+/** Binary links notation v1: bigint preserves unsigned 64-bit references. */
+export class External {
+  value: bigint;
+  constructor(value: bigint | number);
+}
+export class ArityRange {
+  min: bigint;
+  max: bigint | null;
+  constructor(min?: bigint | number, max?: bigint | number | null);
+  contains(length: bigint | number): boolean;
+  readonly fixed: boolean;
+  static parse(text: string): ArityRange;
+}
+export interface BinaryLimits {
+  maxLinks: number;
+  maxReferences: number;
+  maxNodes: number;
+  maxStringBytes: number;
+  maxDepth: number;
+}
+export class DecodeLimits implements BinaryLimits {
+  maxLinks: number;
+  maxReferences: number;
+  maxNodes: number;
+  maxStringBytes: number;
+  maxDepth: number;
+  constructor(values?: Partial<BinaryLimits>);
+  static unlimited(): DecodeLimits;
+}
+export class BinaryLinoOptions {
+  externalReferences: boolean;
+  arity: ArityRange;
+  packedWidths: boolean;
+  constructor(
+    externalReferences?: boolean,
+    arity?: ArityRange,
+    packedWidths?: boolean
+  );
+  static ofPacket(packet: LinksPacket): BinaryLinoOptions;
+}
+export type PacketReference = bigint | number | External;
+export type AddressedLink = [bigint | number, PacketReference[]];
+export class Section {
+  gap: bigint;
+  arity: ArityRange;
+  width: number;
+  links: PacketReference[][];
+  constructor(
+    gap: bigint | number,
+    arity: ArityRange,
+    width: number,
+    links: PacketReference[][]
+  );
+}
+export class PacketReader {
+  bytes: Uint8Array;
+  offset: number;
+  constructor(bytes: Uint8Array, offset?: number);
+  read(limits?: DecodeLimits): LinksPacket | null;
+}
+export class LinksPacket {
+  externalReferences: boolean;
+  sections: Section[];
+  constructor(externalReferences?: boolean, sections?: Section[]);
+  links(): [bigint, (bigint | External)[]][];
+  validate(limits?: DecodeLimits): this;
+  toBytes(limits?: DecodeLimits): Uint8Array;
+  static fromBytes(bytes: Uint8Array, limits?: DecodeLimits): LinksPacket;
+  static parseLinks(text: string): [bigint, (bigint | External)[]][];
+  static pack(
+    externalReferences: boolean,
+    links: AddressedLink[],
+    packedWidths?: boolean
+  ): LinksPacket;
+}
+export class BinaryLinoCodec {
+  options: BinaryLinoOptions;
+  limits: DecodeLimits;
+  constructor(options?: BinaryLinoOptions, limits?: DecodeLimits);
+  encodePacket(document: Link[]): LinksPacket;
+  encode(document: Link[]): Uint8Array;
+  decodePacket(packet: LinksPacket): Link[];
+  decode(bytes: Uint8Array): Link[];
+  parseDocument(text: string, parser?: Parser): Link[];
+  formatDocument(document: Link[]): string;
+  encodeText(text: string, parser?: Parser): Uint8Array;
+  decodeText(bytes: Uint8Array): string;
+}
+export function formatBinaryDocument(document: Link[]): string;
+export function formatBinaryReference(reference: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.21.3",
+  "version": "0.23.0",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -32,10 +32,10 @@
   },
   "homepage": "https://github.com/link-foundation/links-notation#readme",
   "devDependencies": {
-    "bun-types": "^1.4.0",
-    "eslint": "^10.9.1",
+    "bun-types": "^1.4.2",
+    "eslint": "^10.12.0",
     "peggy": "^5.1.0",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.9",
     "typescript": "^7.0.2"
   }
 }