@push.rocks/smartlinuxrepo 1.1.1 → 1.2.0

package/ts/rpm/repodata.ts

@@ -23,9 +23,10 @@ import { element, textElement, XML_HEADER } from './xml.js';
  * createrepo_c 1.2.6 `cr_is_primary` (`src/misc.h:111-119`): paths under
  * `/etc/`, exactly `/usr/lib/sendmail`, or containing `bin/` anywhere. It is
  * applied to every file entry, directories and ghosts included
- * (`src/xml_dump.c:206`).
+ * (`src/xml_dump.c:206`). `buildRpmIndex` lists such files in `primary`
+ * besides the executable ones, where Gitea lists only the executable ones.
  */
-export function isPrimaryPath(pathArg: string): boolean {
+export function isRpmPrimaryPath(pathArg: string): boolean {
   return pathArg.startsWith('/etc/') || pathArg === '/usr/lib/sendmail' || pathArg.includes('bin/');
 }
 
@@ -128,7 +129,7 @@ export function renderRepomd(dataArg: IRepomdData[]): string {
 
 function renderPrimaryPackage(recordArg: IRpmPackageRecord): string {
   const metadata = recordArg.metadata;
-  const files = metadata.files.filter((file) => file.isExecutable || isPrimaryPath(file.path));
+  const files = metadata.files.filter((file) => file.isExecutable || isRpmPrimaryPath(file.path));
   return element(
     'package',
     [['type', 'rpm']],

package/ts/rpm/repodatareader.ts

@@ -0,0 +1,582 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { resolveLinuxPackageLimits, type ILinuxPackageLimits } from '../shared/limits.js';
+import type { TLinuxCompression } from '../shared/types.js';
+import { assertLinuxCompression, assertReaderBytes, assertReaderInput, readIndexDocument } from '../readers/document.js';
+import { scanXmlDocument, type IXmlAttribute, type IXmlFrameScan, type IXmlUnitHandler } from './xmlreader.js';
+
+/** One attribute of a root element, its value decoded. */
+export interface IRpmXmlAttribute {
+  readonly name: string;
+  readonly value: string;
+}
+
+/** The parts of a repodata document outside its units, as exact bytes. */
+export interface IRpmXmlFrame {
+  /** The bytes before the root start tag (XML declaration, comments, whitespace). */
+  readonly prolog: Uint8Array;
+  readonly rootName: string;
+  /** The exact root start tag, `<metadata …>`. */
+  readonly rootStartTag: Uint8Array;
+  /** The root's attributes in order, values decoded. */
+  readonly rootAttributes: readonly IRpmXmlAttribute[];
+  /** The root's `xmlns` value; `''` when absent. */
+  readonly namespace: string;
+  /** The exact root end tag, `</metadata>`; empty for an empty-element root. */
+  readonly rootEndTag: Uint8Array;
+  /** The bytes after the root end tag. */
+  readonly trailer: Uint8Array;
+}
+
+/** Which repodata document `readRpmRepodata` reads; the caller names it from the repomd `type`. */
+export type TRpmRepodataDocument = 'primary' | 'filelists' | 'other';
+
+/** One `<file>` of a package. */
+export interface IRpmRepodataFile {
+  readonly path: string;
+  /** The `type` attribute as written (`dir`, `ghost`); `''` when absent. */
+  readonly type: string;
+}
+
+/** One `<package>` unit of primary, filelists or other. */
+export interface IRpmRepodataPackage {
+  /** The element from `<` of its start tag to `>` of its end tag (a view into `decoded`). */
+  readonly bytes: Uint8Array;
+  /** The element's offset in `decoded`. */
+  readonly offset: number;
+  /** primary: the text of `<checksum pkgid="YES">`; filelists and other: the `pkgid` attribute. */
+  readonly pkgid: string;
+  /** primary: the `<name>` and `<arch>` text; filelists and other: the attributes. `''` when absent. */
+  readonly name: string;
+  readonly arch: string;
+  /** The `<version>` attributes `epoch`, `ver`, `rel`; `''` when absent. */
+  readonly epoch: string;
+  readonly version: string;
+  readonly release: string;
+  /** primary's `<size>` attributes (`''` when absent); null when there is no `<size>` element (always in filelists and other). */
+  readonly size: { readonly package: string; readonly installed: string; readonly archive: string } | null;
+  /** primary `<format><file>`, filelists `<file>`, in order; `[]` when none (always in `other`). */
+  readonly files: readonly IRpmRepodataFile[];
+}
+
+/** A primary, filelists or other document read into its frame and packages. */
+export interface IRpmRepodata extends IRpmXmlFrame {
+  /** The decompressed document (a copy for `'none'`); every `offset` indexes into it. */
+  readonly decoded: Uint8Array;
+  readonly document: TRpmRepodataDocument;
+  /** Every `<package>` in document order, duplicates included. */
+  readonly packages: readonly IRpmRepodataPackage[];
+}
+
+/** A `<checksum>` or `<open-checksum>` of repomd. */
+export interface IRpmRepomdChecksum {
+  /** The `type` attribute; `''` when absent. */
+  readonly type: string;
+  readonly value: string;
+}
+
+/** One `<data>` unit of repomd. */
+export interface IRpmRepomdData {
+  readonly bytes: Uint8Array;
+  readonly offset: number;
+  readonly type: string;
+  /** The `<location href>`. */
+  readonly location: string;
+  readonly checksum: IRpmRepomdChecksum;
+  readonly openChecksum: IRpmRepomdChecksum | null;
+  /** The `<timestamp>`, `<size>` and `<open-size>` text as written; null when absent. */
+  readonly timestamp: string | null;
+  readonly size: string | null;
+  readonly openSize: string | null;
+}
+
+/** A root child of repomd other than `<data>` (createrepo_c's `<revision>`, `<tags>`), raw. */
+export interface IRpmRepomdElement {
+  readonly name: string;
+  readonly bytes: Uint8Array;
+  readonly offset: number;
+}
+
+/** A `repomd.xml` read into its frame, `<data>` units and other elements. */
+export interface IRpmRepomd extends IRpmXmlFrame {
+  readonly data: readonly IRpmRepomdData[];
+  readonly otherElements: readonly IRpmRepomdElement[];
+}
+
+/** One package of an `<update>`'s `<pkglist>`. */
+export interface IRpmUpdateInfoPackage {
+  /** The enclosing `<collection short>`; `''` when absent. */
+  readonly collection: string;
+  /** The `<package>` attributes; `''` when absent. */
+  readonly name: string;
+  readonly epoch: string;
+  readonly version: string;
+  readonly release: string;
+  readonly arch: string;
+  readonly src: string;
+  /** The `<filename>` text; `''` when absent. */
+  readonly fileName: string;
+}
+
+/** One `<update>` unit of updateinfo. */
+export interface IRpmUpdateInfoUpdate {
+  readonly bytes: Uint8Array;
+  readonly offset: number;
+  /** The `<id>` text: the unit key. */
+  readonly id: string;
+  /** Every package of every collection, in order. */
+  readonly packages: readonly IRpmUpdateInfoPackage[];
+}
+
+/** An `updateinfo` document read into its frame and updates. */
+export interface IRpmUpdateInfo extends IRpmXmlFrame {
+  /** The decompressed document (a copy for `'none'`); every `offset` indexes into it. */
+  readonly decoded: Uint8Array;
+  /** Every `<update>` in document order, duplicates included. */
+  readonly updates: readonly IRpmUpdateInfoUpdate[];
+}
+
+const DOCUMENTS: ReadonlyMap<string, string> = new Map<TRpmRepodataDocument, string>([
+  ['primary', 'metadata'],
+  ['filelists', 'filelists'],
+  ['other', 'otherdata'],
+]);
+
+/**
+ * Reads a `primary`, `filelists` or `other` document (`.xml`, `.xml.gz`,
+ * `.xml.xz`, `.xml.zst`; the caller names `compression` and `document`) into
+ * its frame and `<package>` units. The XML rules are the strict scanner's
+ * (see `IRpmXmlFrame`; any refusal is `malformed-index`): the root must be
+ * `<metadata>`, `<filelists>` or `<otherdata>` for the document, and its
+ * children `<package>` elements with only whitespace between them, which is
+ * not returned. A package without its key (primary `<checksum pkgid="YES">`,
+ * filelists and other `pkgid`) is `missing-field` (`pkgid`); a package with
+ * two of an element the view reads (`<name>`, `<arch>`, `<version>`, `<size>`,
+ * a key `<checksum>`) is `malformed-index`.
+ *
+ * Bounds: the decoded document by `maxIndexBytes`, packages and files per
+ * package by `maxEntries`, one package by `maxMetadataBytes`, one start tag
+ * by `maxHeaderBytes`. Duplicates are kept; all bytes are views into `decoded`.
+ */
+export async function readRpmRepodata(inputArg: {
+  bytes: Uint8Array;
+  compression: TLinuxCompression;
+  document: TRpmRepodataDocument;
+  limits?: Partial<ILinuxPackageLimits>;
+}): Promise<IRpmRepodata> {
+  assertReaderInput(inputArg);
+  assertReaderBytes(inputArg.bytes);
+  assertLinuxCompression(inputArg.compression);
+  const document = inputArg.document;
+  const rootName = typeof document === 'string' ? DOCUMENTS.get(document) : undefined;
+  if (rootName === undefined) {
+    throw new LinuxRepoError('invalid-input', "document must be 'primary', 'filelists' or 'other'", {
+      field: 'document',
+      value: typeof document === 'string' ? document : typeof document,
+    });
+  }
+  const limits = resolveLinuxPackageLimits(inputArg.limits);
+  const decoded = await readIndexDocument(inputArg.bytes, inputArg.compression, limits);
+  const packages: IRpmRepodataPackage[] = [];
+  const frame = scanXmlDocument(decoded, {
+    rootName,
+    unitName: 'package',
+    keepOtherChildren: false,
+    limits,
+    createUnit: (startArg) => new PackageHandler(document, startArg, limits),
+    unit: (handlerArg, startArg, endArg) => {
+      packages.push((handlerArg as PackageHandler).result(decoded.subarray(startArg, endArg)));
+    },
+    other: () => undefined,
+  });
+  return { ...frameOf(decoded, rootName, frame), decoded, document, packages };
+}
+
+/**
+ * Reads an `updateinfo` document into its frame and `<update>` units: the
+ * root must be `<updates>`, the unit key is the `<id>` text (none is
+ * `missing-field`, two are `malformed-index`), and the packages are the
+ * `<pkglist><collection short><package …><filename>` entries in order (a
+ * package with two `<filename>` elements is `malformed-index`). XML rules,
+ * bounds and ownership as `readRpmRepodata`; packages per update count against
+ * `maxEntries`.
+ */
+export async function readRpmUpdateInfo(inputArg: {
+  bytes: Uint8Array;
+  compression: TLinuxCompression;
+  limits?: Partial<ILinuxPackageLimits>;
+}): Promise<IRpmUpdateInfo> {
+  assertReaderInput(inputArg);
+  assertReaderBytes(inputArg.bytes);
+  assertLinuxCompression(inputArg.compression);
+  const limits = resolveLinuxPackageLimits(inputArg.limits);
+  const decoded = await readIndexDocument(inputArg.bytes, inputArg.compression, limits);
+  const updates: IRpmUpdateInfoUpdate[] = [];
+  const frame = scanXmlDocument(decoded, {
+    rootName: 'updates',
+    unitName: 'update',
+    keepOtherChildren: false,
+    limits,
+    createUnit: (startArg) => new UpdateHandler(startArg, limits),
+    unit: (handlerArg, startArg, endArg) => {
+      updates.push((handlerArg as UpdateHandler).result(decoded.subarray(startArg, endArg)));
+    },
+    other: () => undefined,
+  });
+  return { ...frameOf(decoded, 'updates', frame), decoded, updates };
+}
+
+/**
+ * Reads a plain `repomd.xml` into its frame, `<data>` units and the other
+ * root children (kept raw, in `otherElements`). A `<data>` without a `type`
+ * attribute, `<checksum>` or `<location href>` is `missing-field`; a `<data>`
+ * with two of `<checksum>`, `<open-checksum>`, `<location>`, `<timestamp>`,
+ * `<size>` or `<open-size>` is `malformed-index`. XML rules and bounds as
+ * `readRpmRepodata` (the plain input counts against `maxIndexBytes`); all
+ * bytes are views into a copy of the input.
+ */
+export async function readRpmRepomd(inputArg: {
+  bytes: Uint8Array;
+  limits?: Partial<ILinuxPackageLimits>;
+}): Promise<IRpmRepomd> {
+  assertReaderInput(inputArg);
+  assertReaderBytes(inputArg.bytes);
+  const limits = resolveLinuxPackageLimits(inputArg.limits);
+  const decoded = await readIndexDocument(inputArg.bytes, 'none', limits);
+  const data: IRpmRepomdData[] = [];
+  const otherElements: IRpmRepomdElement[] = [];
+  const frame = scanXmlDocument(decoded, {
+    rootName: 'repomd',
+    unitName: 'data',
+    keepOtherChildren: true,
+    limits,
+    createUnit: (startArg) => new RepomdDataHandler(startArg),
+    unit: (handlerArg, startArg, endArg) => {
+      data.push((handlerArg as RepomdDataHandler).result(decoded.subarray(startArg, endArg)));
+    },
+    other: (nameArg, startArg, endArg) => {
+      otherElements.push({ name: nameArg, bytes: decoded.subarray(startArg, endArg), offset: startArg });
+    },
+  });
+  return { ...frameOf(decoded, 'repomd', frame), data, otherElements };
+}
+
+function frameOf(decodedArg: Uint8Array, rootNameArg: string, frameArg: IXmlFrameScan): IRpmXmlFrame {
+  return {
+    prolog: decodedArg.subarray(0, frameArg.rootStart),
+    rootName: rootNameArg,
+    rootStartTag: decodedArg.subarray(frameArg.rootStart, frameArg.rootStartEnd),
+    rootAttributes: frameArg.rootAttributes.map((attribute) => ({ name: attribute.name, value: attribute.value })),
+    namespace: attributeOf(frameArg.rootAttributes, 'xmlns'),
+    rootEndTag: decodedArg.subarray(frameArg.rootEndStart, frameArg.rootEnd),
+    trailer: decodedArg.subarray(frameArg.rootEnd),
+  };
+}
+
+function attributeOf(attributesArg: readonly IXmlAttribute[], nameArg: string): string {
+  return attributesArg.find((attribute) => attribute.name === nameArg)?.value ?? '';
+}
+
+function hasAttribute(attributesArg: readonly IXmlAttribute[], nameArg: string): boolean {
+  return attributesArg.some((attribute) => attribute.name === nameArg);
+}
+
+/** The path of open element names inside one unit, for the handlers' context. */
+abstract class UnitHandler implements IXmlUnitHandler {
+  protected readonly path: string[] = [];
+
+  constructor(protected readonly offset: number) {}
+
+  public start(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean {
+    const capture = this.open(depthArg, nameArg, attributesArg);
+    this.path.push(nameArg);
+    return capture;
+  }
+
+  public end(depthArg: number, nameArg: string, textArg: string | null): void {
+    this.path.pop();
+    this.close(depthArg, nameArg, textArg);
+  }
+
+  /** The parent element's name at `depthArg` (the unit element at depth 1). */
+  protected parent(): string | undefined {
+    return this.path[this.path.length - 1];
+  }
+
+  protected duplicate(whatArg: string): LinuxRepoError {
+    return new LinuxRepoError('malformed-index', `a unit holds two ${whatArg} elements`, { field: whatArg, value: this.offset });
+  }
+
+  protected abstract open(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean;
+  protected abstract close(depthArg: number, nameArg: string, textArg: string | null): void;
+}
+
+class PackageHandler extends UnitHandler {
+  private pkgid: string | null = null;
+  private name: string | null = null;
+  private arch: string | null = null;
+  private version: { epoch: string; version: string; release: string } | null = null;
+  private size: { package: string; installed: string; archive: string } | null = null;
+  private readonly files: IRpmRepodataFile[] = [];
+  private fileType = '';
+
+  constructor(
+    private readonly document: TRpmRepodataDocument,
+    offsetArg: number,
+    private readonly limits: Readonly<ILinuxPackageLimits>,
+  ) {
+    super(offsetArg);
+  }
+
+  protected open(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean {
+    if (depthArg === 0) {
+      if (this.document !== 'primary') {
+        if (!hasAttribute(attributesArg, 'pkgid')) {
+          throw this.missingKey();
+        }
+        this.pkgid = attributeOf(attributesArg, 'pkgid');
+        this.name = attributeOf(attributesArg, 'name');
+        this.arch = attributeOf(attributesArg, 'arch');
+      }
+      return false;
+    }
+    const parent = this.parent();
+    if (depthArg === 1) {
+      if (nameArg === 'version') {
+        if (this.version !== null) {
+          throw this.duplicate('<version>');
+        }
+        this.version = {
+          epoch: attributeOf(attributesArg, 'epoch'),
+          version: attributeOf(attributesArg, 'ver'),
+          release: attributeOf(attributesArg, 'rel'),
+        };
+        return false;
+      }
+      if (this.document === 'primary') {
+        if (nameArg === 'name' || nameArg === 'arch') {
+          return true;
+        }
+        if (nameArg === 'checksum') {
+          return attributeOf(attributesArg, 'pkgid') === 'YES';
+        }
+        if (nameArg === 'size') {
+          if (this.size !== null) {
+            throw this.duplicate('<size>');
+          }
+          this.size = {
+            package: attributeOf(attributesArg, 'package'),
+            installed: attributeOf(attributesArg, 'installed'),
+            archive: attributeOf(attributesArg, 'archive'),
+          };
+          return false;
+        }
+        return false;
+      }
+      if (this.document === 'filelists' && nameArg === 'file') {
+        return this.openFile(attributesArg);
+      }
+      return false;
+    }
+    if (depthArg === 2 && this.document === 'primary' && parent === 'format' && nameArg === 'file') {
+      return this.openFile(attributesArg);
+    }
+    return false;
+  }
+
+  protected close(depthArg: number, nameArg: string, textArg: string | null): void {
+    if (textArg === null) {
+      return;
+    }
+    if (nameArg === 'file') {
+      this.files.push({ path: textArg, type: this.fileType });
+    } else if (nameArg === 'name') {
+      if (this.name !== null) {
+        throw this.duplicate('<name>');
+      }
+      this.name = textArg;
+    } else if (nameArg === 'arch') {
+      if (this.arch !== null) {
+        throw this.duplicate('<arch>');
+      }
+      this.arch = textArg;
+    } else if (nameArg === 'checksum') {
+      if (this.pkgid !== null) {
+        throw this.duplicate('<checksum pkgid="YES">');
+      }
+      this.pkgid = textArg;
+    }
+  }
+
+  private openFile(attributesArg: readonly IXmlAttribute[]): boolean {
+    if (this.files.length + 1 > this.limits.maxEntries) {
+      throw limitExceeded('maxEntries', this.limits.maxEntries, 'files per package');
+    }
+    this.fileType = attributeOf(attributesArg, 'type');
+    return true;
+  }
+
+  private missingKey(): LinuxRepoError {
+    return new LinuxRepoError('missing-field', `a ${this.document} <package> has no pkgid`, { field: 'pkgid', value: this.offset });
+  }
+
+  public result(bytesArg: Uint8Array): IRpmRepodataPackage {
+    if (this.pkgid === null) {
+      throw this.missingKey();
+    }
+    return {
+      bytes: bytesArg,
+      offset: this.offset,
+      pkgid: this.pkgid,
+      name: this.name ?? '',
+      arch: this.arch ?? '',
+      epoch: this.version?.epoch ?? '',
+      version: this.version?.version ?? '',
+      release: this.version?.release ?? '',
+      size: this.size,
+      files: this.files,
+    };
+  }
+}
+
+class UpdateHandler extends UnitHandler {
+  private id: string | null = null;
+  private collection = '';
+  private pending: { attributes: readonly IXmlAttribute[]; fileName: string | null } | null = null;
+  private readonly packages: IRpmUpdateInfoPackage[] = [];
+
+  constructor(
+    offsetArg: number,
+    private readonly limits: Readonly<ILinuxPackageLimits>,
+  ) {
+    super(offsetArg);
+  }
+
+  protected open(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean {
+    const parent = this.parent();
+    if (depthArg === 1 && nameArg === 'id') {
+      return true;
+    }
+    if (depthArg === 2 && parent === 'pkglist' && nameArg === 'collection') {
+      this.collection = attributeOf(attributesArg, 'short');
+      return false;
+    }
+    if (depthArg === 3 && parent === 'collection' && this.path[1] === 'pkglist' && nameArg === 'package') {
+      if (this.packages.length + 1 > this.limits.maxEntries) {
+        throw limitExceeded('maxEntries', this.limits.maxEntries, 'packages per update');
+      }
+      this.pending = { attributes: attributesArg, fileName: null };
+      return false;
+    }
+    if (depthArg === 4 && parent === 'package' && this.pending !== null && nameArg === 'filename') {
+      return true;
+    }
+    return false;
+  }
+
+  protected close(depthArg: number, nameArg: string, textArg: string | null): void {
+    if (depthArg === 1 && nameArg === 'id' && textArg !== null) {
+      if (this.id !== null) {
+        throw this.duplicate('<id>');
+      }
+      this.id = textArg;
+    } else if (depthArg === 4 && nameArg === 'filename' && textArg !== null && this.pending !== null) {
+      if (this.pending.fileName !== null) {
+        throw this.duplicate('<filename>');
+      }
+      this.pending.fileName = textArg;
+    } else if (depthArg === 3 && nameArg === 'package' && this.pending !== null) {
+      const attributes = this.pending.attributes;
+      this.packages.push({
+        collection: this.collection,
+        name: attributeOf(attributes, 'name'),
+        epoch: attributeOf(attributes, 'epoch'),
+        version: attributeOf(attributes, 'version'),
+        release: attributeOf(attributes, 'release'),
+        arch: attributeOf(attributes, 'arch'),
+        src: attributeOf(attributes, 'src'),
+        fileName: this.pending.fileName ?? '',
+      });
+      this.pending = null;
+    } else if (depthArg === 2 && nameArg === 'collection') {
+      this.collection = '';
+    }
+  }
+
+  public result(bytesArg: Uint8Array): IRpmUpdateInfoUpdate {
+    if (this.id === null) {
+      throw new LinuxRepoError('missing-field', 'an <update> has no <id>', { field: 'id', value: this.offset });
+    }
+    return { bytes: bytesArg, offset: this.offset, id: this.id, packages: this.packages };
+  }
+}
+
+class RepomdDataHandler extends UnitHandler {
+  private type: string | null = null;
+  private readonly values = new Map<string, { type: string; text: string | null }>();
+  private pendingType = '';
+
+  protected open(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean {
+    if (depthArg === 0) {
+      if (hasAttribute(attributesArg, 'type')) {
+        this.type = attributeOf(attributesArg, 'type');
+      }
+      return false;
+    }
+    if (depthArg !== 1) {
+      return false;
+    }
+    switch (nameArg) {
+      case 'checksum':
+      case 'open-checksum':
+      case 'timestamp':
+      case 'size':
+      case 'open-size':
+      case 'location':
+        if (this.values.has(nameArg)) {
+          throw this.duplicate(`<${nameArg}>`);
+        }
+        if (nameArg === 'location') {
+          this.values.set(nameArg, { type: '', text: hasAttribute(attributesArg, 'href') ? attributeOf(attributesArg, 'href') : null });
+          return false;
+        }
+        this.pendingType = attributeOf(attributesArg, 'type');
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  protected close(depthArg: number, nameArg: string, textArg: string | null): void {
+    if (depthArg === 1 && textArg !== null) {
+      this.values.set(nameArg, { type: this.pendingType, text: textArg });
+    }
+  }
+
+  public result(bytesArg: Uint8Array): IRpmRepomdData {
+    const missing = (fieldArg: string) =>
+      new LinuxRepoError('missing-field', `a repomd <data> has no ${fieldArg}`, { field: fieldArg, value: this.offset });
+    if (this.type === null) {
+      throw missing('type');
+    }
+    const checksum = this.values.get('checksum');
+    if (checksum === undefined || checksum.text === null) {
+      throw missing('checksum');
+    }
+    const location = this.values.get('location');
+    if (location === undefined || location.text === null) {
+      throw missing('location');
+    }
+    const openChecksum = this.values.get('open-checksum');
+    return {
+      bytes: bytesArg,
+      offset: this.offset,
+      type: this.type,
+      location: location.text,
+      checksum: { type: checksum.type, value: checksum.text },
+      openChecksum: openChecksum === undefined || openChecksum.text === null ? null : { type: openChecksum.type, value: openChecksum.text },
+      timestamp: this.values.get('timestamp')?.text ?? null,
+      size: this.values.get('size')?.text ?? null,
+      openSize: this.values.get('open-size')?.text ?? null,
+    };
+  }
+}