@exornea/zeno-compiler 1.7.0 → 2.3.0

package/dist/emitter.js

@@ -1,10 +1,21 @@
-import { scalarGetterMethod, scalarSetterMethod, scalarTsType, } from "@exornea/zeno-schema";
-import { canWriteFixedArrayStructElement, collectFixedArrayRuntimeImports, emitFixedArrayFieldAccessor, emitFixedArrayObjectFieldWrite, fixedArrayInputElementType, } from "./emitter-fixed-array.js";
+import {} from "@exornea/zeno-schema";
+import { emitAstCheckedSource } from "./emitter-ast.js";
+import { emitField } from "./emitter-fields.js";
+import { emitInputInterface } from "./emitter-input.js";
+import { toLittleEndianLiteral, toPascalCase } from "./emitter-names.js";
+import { collectRuntimeImports } from "./emitter-runtime-imports.js";
+import { emitScanRangeHelper, hasScanKernels, normalizeScanKernelMode, } from "./emitter-scan-kernels.js";
+import { emitStaticFieldAccessor } from "./emitter-static-accessors.js";
 import { method } from "./emitter-template.js";
+import { emitDynamicWriterMethods, emitObjectWriterMethod } from "./emitter-writers.js";
+import { createProjectionSourceMap } from "./source-map.js";
 export function emitStructView(layout, options = {}) {
     return emitProjectionFile([layout], options);
 }
 export function emitProjectionFile(layouts, options = {}) {
+    return emitAstCheckedSource(emitProjectionFileText(layouts, options), "zeno.view.ts").code;
+}
+function emitProjectionFileText(layouts, options = {}) {
     const lines = [];
     const runtimeImports = collectRuntimeImports(layouts);
     const layoutMap = new Map(layouts.map((layout) => [layout.name, layout]));
@@ -20,109 +31,13 @@ export function emitProjectionFile(layouts, options = {}) {
     }
     return lines.join("\n");
 }
-function collectRuntimeImports(layouts) {
-    const imports = new Set(["ProjectionView"]);
-    const layoutMap = new Map(layouts.map((layout) => [layout.name, layout]));
-    for (const layout of layouts) {
-        if (hasTailWriterFields(layout, layoutMap)) {
-            imports.add("DynamicLayoutWriter");
-        }
-        for (const field of layout.fields) {
-            collectFieldRuntimeImports(field, imports);
-        }
-    }
-    return Array.from(imports).sort();
-}
-function collectFieldRuntimeImports(field, imports) {
-    switch (field.kind) {
-        case "fixed-bytes":
-            imports.add("fixedBytesView");
-            imports.add("writeFixedBytes");
-            return;
-        case "fixed-string":
-            imports.add("decodeFixedText");
-            imports.add("fixedBytesView");
-            imports.add("writeFixedText");
-            return;
-        case "dynamic-string":
-            imports.add("Utf8SpanView");
-            return;
-        case "dynamic-bytes":
-            imports.add("BytesSpanView");
-            return;
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    imports.add("ScalarVectorView");
-                    return;
-                case "dynamic-string":
-                    imports.add("Utf8VectorView");
-                    return;
-                case "dynamic-bytes":
-                    imports.add("BytesVectorView");
-                    return;
-                case "fixed-bytes":
-                    imports.add("FixedBytesVectorView");
-                    return;
-                case "fixed-string":
-                    imports.add("FixedStringVectorView");
-                    return;
-                case "struct":
-                    imports.add("StructVectorView");
-                    return;
-                case "pointer":
-                    imports.add("PointerVectorView");
-                    return;
-                default:
-                    return;
-            }
-        case "fixed-array":
-            collectFixedArrayRuntimeImports(field.element, imports);
-            return;
-        default:
-            return;
-    }
-}
-function emitInputInterface(layout) {
-    const lines = [`export interface ${layout.name}ViewInput {`];
-    for (const field of layout.fields) {
-        lines.push(`  readonly ${field.name}: ${fieldInputType(field)};`);
-    }
-    lines.push("}");
-    return lines;
-}
-function fieldInputType(field) {
-    switch (field.kind) {
-        case "scalar":
-            return scalarTsType(field.scalar);
-        case "fixed-bytes":
-        case "dynamic-bytes":
-            return "ArrayLike<number> | Uint8Array";
-        case "fixed-string":
-        case "dynamic-string":
-            return "string";
-        case "struct":
-            return `${field.typeName}ViewInput`;
-        case "pointer":
-            return "number | null";
-        case "fixed-array":
-            return `readonly ${fixedArrayInputElementType(field.element)}[]`;
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    return `readonly ${scalarTsType(field.element.scalar)}[]`;
-                case "fixed-bytes":
-                case "dynamic-bytes":
-                    return "readonly (ArrayLike<number> | Uint8Array)[]";
-                case "fixed-string":
-                case "dynamic-string":
-                    return "readonly string[]";
-                case "struct":
-                    return `readonly ${field.element.typeName}ViewInput[]`;
-                case "pointer":
-                    return "readonly (number | null)[]";
-            }
-    }
+export function emitProjectionFileWithSourceMap(layouts, generatedFile, options = {}) {
+    const sourceMapUrl = `${generatedFile.split(/[\\/]/).pop() ?? generatedFile}.map`;
+    const code = `${emitAstCheckedSource(emitProjectionFileText(layouts, options), generatedFile).code}\n//# sourceMappingURL=${sourceMapUrl}\n`;
+    return {
+        code,
+        sourceMap: createProjectionSourceMap(code, layouts, generatedFile),
+    };
 }
 function emitLayoutConstants(layout) {
     const lines = [];
@@ -134,8 +49,8 @@ function emitLayoutConstants(layout) {
     return lines;
 }
 function emitStructClass(layout, options, layoutMap) {
-    const scalarFields = layout.fields.filter((field) => field.kind === "scalar");
     const littleEndianDefault = toLittleEndianLiteral(layout);
+    const scanKernelMode = normalizeScanKernelMode(options.scanKernels);
     const lines = [`export class ${layout.name}View extends ProjectionView {`];
     lines.push(...method `
 static readonly byteLength = ${layout.byteLength};
@@ -162,585 +77,41 @@ private static assertPointerTargetRange(view: DataView, targetOffset: number, by
   }
 }`);
     }
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
+    if (hasScanKernels(layout, scanKernelMode)) {
         lines.push("");
-        lines.push(...method `${scalarFields.map((field) => `private $${field.name}Offset = ${field.offset};`)}`);
+        lines.push(...emitScanRangeHelper(layout));
     }
     lines.push("");
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
-        lines.push(...method `
-constructor(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}) {
-  super(view, baseOffset, littleEndian);
-  this.$refreshOffsets();
-}
-
-private $refreshOffsets(): void {
-${scalarFields.map((field) => `  this.$${field.name}Offset = this.baseOffset + ${field.offset};`)}
-}
-
-override rebase(baseOffset: number): this {
-  super.rebase(baseOffset);
-  this.$refreshOffsets();
-  return this;
-}
-
-override rebaseUnchecked(baseOffset: number): this {
-  super.rebaseUnchecked(baseOffset);
-  this.$refreshOffsets();
-  return this;
-}`);
-    }
-    else {
-        lines.push(...method `
+    lines.push(...method `
 constructor(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}) {
   super(view, baseOffset, littleEndian);
 }`);
-    }
     lines.push("");
     lines.push(...method `
 static at(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): ${layout.name}View {
   return new ${layout.name}View(view, baseOffset, littleEndian);
 }`);
     lines.push("");
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
-        lines.push(...method `
-moveTo(index: number): this {
-  this.moveToIndex(index, ${layout.name}View.byteLength);
-  this.$refreshOffsets();
-  return this;
-}`);
-    }
-    else {
-        lines.push(...method `
+    lines.push(...method `
 moveTo(index: number): this {
   return this.moveToIndex(index, ${layout.name}View.byteLength);
 }`);
-    }
     lines.push("");
     lines.push(...method `
 moveToUnchecked(index: number): this {
   return this.rebaseUnchecked(index * ${layout.byteLength});
 }`);
     lines.push("");
-    const writerLines = emitDynamicWriterMethods(layout, layoutMap);
-    for (const line of writerLines) {
-        lines.push(line);
-    }
-    if (writerLines.length > 0) {
-        lines.push("");
-    }
-    const objectWriterLines = emitObjectWriterMethod(layout, layoutMap);
-    for (const line of objectWriterLines) {
-        lines.push(line);
-    }
-    if (objectWriterLines.length > 0) {
-        lines.push("");
-    }
+    lines.push(...emitLayerBlock(emitDynamicWriterMethods(layout, layoutMap)));
+    lines.push(...emitLayerBlock(emitObjectWriterMethod(layout, layoutMap)));
     for (const field of layout.fields) {
-        const staticAccessorLines = emitStaticFieldAccessor(layout, field);
-        for (const line of staticAccessorLines) {
-            lines.push(line);
-        }
-        if (staticAccessorLines.length > 0) {
-            lines.push("");
-        }
-        for (const line of emitField(layout, field, options)) {
-            lines.push(line);
-        }
-        lines.push("");
+        lines.push(...emitLayerBlock(emitStaticFieldAccessor(layout, field, scanKernelMode)));
+        lines.push(...emitLayerBlock(emitField(layout, field)));
     }
     lines.push("}");
     return lines;
 }
-function emitDynamicWriterMethods(layout, layoutMap) {
-    const fields = layout.fields.filter((field) => isTailWriterField(field, layoutMap));
-    if (fields.length === 0) {
-        return [];
-    }
-    const lines = [
-        ...method `
-static createWriter(view: DataView, baseOffset = 0, tailOffset = ${layout.name}View.byteLength, littleEndian = ${toLittleEndianLiteral(layout)}): DynamicLayoutWriter {
-  return new DynamicLayoutWriter(view, tailOffset, baseOffset, littleEndian);
-}`,
-        "",
-    ];
-    for (const field of fields) {
-        const pascalName = toPascalCase(field.name);
-        switch (field.kind) {
-            case "dynamic-string":
-                lines.push(...method `
-static write${pascalName}(writer: DynamicLayoutWriter, value: string) {
-  return writer.writeText(${layout.name}View.${field.name}Offset, value, ${encodingLiteral(field.encoding)});
-}`);
-                break;
-            case "dynamic-bytes":
-                lines.push(...method `
-static write${pascalName}(writer: DynamicLayoutWriter, value: ArrayLike<number> | Uint8Array) {
-  return writer.writeBytes(${layout.name}View.${field.name}Offset, value);
-}`);
-                break;
-            case "vector":
-                lines.push(...emitVectorWriterMethod(layout, layoutMap, field, pascalName));
-                break;
-        }
-        lines.push("");
-    }
-    lines.pop();
-    return lines;
-}
-const vectorWriterEmitters = {
-    "dynamic-string": ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly string[]) {
-  return writer.writeTextVector(${layout.name}View.${field.name}Offset, values, ${encodingLiteral(field.element.encoding)});
-}`,
-    "dynamic-bytes": ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly (ArrayLike<number> | Uint8Array)[]) {
-  return writer.writeBytesVector(${layout.name}View.${field.name}Offset, values);
-}`,
-    "fixed-bytes": ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly (ArrayLike<number> | Uint8Array)[]) {
-  return writer.writeFixedBytesVector(${layout.name}View.${field.name}Offset, values, ${field.element.byteLength});
-}`,
-    "fixed-string": ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly string[]) {
-  return writer.writeFixedTextVector(${layout.name}View.${field.name}Offset, values, ${field.element.byteLength}, ${encodingLiteral(field.element.encoding)});
-}`,
-    scalar: ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly ${scalarTsType(field.element.scalar)}[]) {
-  return writer.writeScalarVector(${layout.name}View.${field.name}Offset, "${field.element.scalar}", values);
-}`,
-    struct: ({ layout, layoutMap, field, pascalName }) => {
-        const elementLayout = layoutMap.get(field.element.typeName);
-        const alignment = elementLayout?.alignment ?? 1;
-        return method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly ${field.element.typeName}ViewInput[]) {
-  return writer.writeStructVector(${layout.name}View.${field.name}Offset, values, ${field.element.byteLength}, (view, value, baseOffset, littleEndian) => ${field.element.typeName}View.write(view, value, baseOffset, littleEndian), ${alignment});
-}`;
-    },
-    pointer: ({ layout, field, pascalName }) => method `
-static write${pascalName}(writer: DynamicLayoutWriter, values: readonly (number | null)[]) {
-  return writer.writePointerVector(${layout.name}View.${field.name}Offset, values, ${field.element.targetTypeName}View.byteLength);
-}`,
-};
-function emitVectorWriterMethod(layout, layoutMap, field, pascalName) {
-    const emitWriter = vectorWriterEmitters[field.element.kind];
-    return emitWriter({ layout, layoutMap, field, pascalName });
-}
-function emitObjectWriterMethod(layout, layoutMap) {
-    if (!canEmitObjectWriter(layout, layoutMap)) {
-        return [];
-    }
-    const hasTailFields = hasTailWriterFields(layout, layoutMap);
-    const returnType = hasTailFields ? "DynamicLayoutWriter" : "void";
-    const bodyLines = [];
-    if (hasTailFields) {
-        bodyLines.push(`  const writer = ${layout.name}View.createWriter(view, baseOffset, ${layout.name}View.byteLength, littleEndian);`);
-    }
-    for (const field of layout.fields) {
-        bodyLines.push(...emitObjectFieldWrite(layout, field));
-    }
-    if (hasTailFields) {
-        bodyLines.push("  return writer;");
-    }
-    return method `
-static write(view: DataView, value: ${layout.name}ViewInput, baseOffset = 0, littleEndian = ${toLittleEndianLiteral(layout)}): ${returnType} {
-${bodyLines}
-}`;
-}
-function emitObjectFieldWrite(layout, field) {
-    const pascalName = toPascalCase(field.name);
-    switch (field.kind) {
-        case "scalar":
-            return [
-                `  ${layout.name}View.set${pascalName}(view, value.${field.name}, baseOffset, littleEndian);`,
-            ];
-        case "fixed-bytes":
-            return [
-                `  writeFixedBytes(view.buffer, view.byteOffset + baseOffset + ${field.offset}, ${field.byteLength}, value.${field.name});`,
-            ];
-        case "fixed-string":
-            return [
-                `  writeFixedText(view.buffer, view.byteOffset + baseOffset + ${field.offset}, ${field.byteLength}, value.${field.name}, ${encodingLiteral(field.encoding)});`,
-            ];
-        case "dynamic-string":
-        case "dynamic-bytes":
-            return [`  ${layout.name}View.write${pascalName}(writer, value.${field.name});`];
-        case "struct":
-            return [
-                `  ${field.typeName}View.write(view, value.${field.name}, baseOffset + ${field.offset}, littleEndian);`,
-            ];
-        case "pointer":
-            return [
-                `  ${layout.name}View.set${pascalName}TargetOffset(view, value.${field.name}, baseOffset, littleEndian);`,
-            ];
-        case "fixed-array":
-            return emitFixedArrayObjectFieldWrite(field, encodingLiteral);
-        case "vector":
-            return [`  ${layout.name}View.write${pascalName}(writer, value.${field.name});`];
-    }
-}
-function emitStaticFieldAccessor(layout, field) {
-    if (field.kind === "pointer") {
-        const pascalName = toPascalCase(field.name);
-        const littleEndianDefault = toLittleEndianLiteral(layout);
-        const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
-        const pointerPosition = `baseOffset + ${field.offset}`;
-        return method `
-static getRaw${pascalName}RelativeOffset(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): number {
-  return view.getUint32(baseOffset + ${field.offset}, littleEndian);
-}
-static get${pascalName}RelativeOffset(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): number | null {
-  const rawValue = ${layout.name}View.getRaw${pascalName}RelativeOffset(view, baseOffset, littleEndian);
-  if (rawValue === 0xffffffff) {
-    return null;
-  }
-  return view.getInt32(baseOffset + ${field.offset}, littleEndian);
-}
-static set${pascalName}RelativeOffset(view: DataView, value: number | null, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {
-  if (value === null) {
-    view.setUint32(baseOffset + ${field.offset}, 0xffffffff, littleEndian);
-    return;
-  }
-  ${layout.name}View.assertPointer32Payload(value);
-  view.setInt32(baseOffset + ${field.offset}, value, littleEndian);
-}
-static getUnchecked${pascalName}TargetOffset(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): number | null {
-  const relativeOffset = ${layout.name}View.get${pascalName}RelativeOffset(view, baseOffset, littleEndian);
-  if (relativeOffset === null) {
-    return null;
-  }
-  return ${pointerPosition} + relativeOffset;
-}
-static get${pascalName}TargetOffset(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): number | null {
-  const targetOffset = ${layout.name}View.getUnchecked${pascalName}TargetOffset(view, baseOffset, littleEndian);
-  if (targetOffset === null) {
-    return null;
-  }
-  ${layout.name}View.assertPointerTargetRange(view, targetOffset, ${field.targetTypeName}View.byteLength);
-  return targetOffset;
-}
-static setUnchecked${pascalName}TargetOffset(view: DataView, targetOffset: number | null, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {
-  if (targetOffset === null) {
-    ${layout.name}View.set${pascalName}RelativeOffset(view, null, baseOffset, littleEndian);
-    return;
-  }
-  const relativeOffset = targetOffset - (${pointerPosition});
-  ${layout.name}View.set${pascalName}RelativeOffset(view, relativeOffset, baseOffset, littleEndian);
-}
-static set${pascalName}TargetOffset(view: DataView, targetOffset: number | null, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {
-  if (targetOffset !== null) {
-    ${layout.name}View.assertPointerTargetRange(view, targetOffset, ${field.targetTypeName}View.byteLength);
-  }
-  ${layout.name}View.setUnchecked${pascalName}TargetOffset(view, targetOffset, baseOffset, littleEndian);
-}
-static get${pascalName}RelativeOffsetAt(view: DataView, index: number, littleEndian = ${littleEndianDefault}): number | null {
-  const rawValue = ${layout.name}View.getRaw${pascalName}RelativeOffset(view, index * ${layout.byteLength}, littleEndian);
-  if (rawValue === 0xffffffff) {
-    return null;
-  }
-  return view.getInt32(${indexOffset}, littleEndian);
-}
-static set${pascalName}RelativeOffsetAt(view: DataView, value: number | null, index: number, littleEndian = ${littleEndianDefault}): void {
-  if (value === null) {
-    view.setUint32(${indexOffset}, 0xffffffff, littleEndian);
-    return;
-  }
-  ${layout.name}View.assertPointer32Payload(value);
-  view.setInt32(${indexOffset}, value, littleEndian);
-}`;
-    }
-    if (field.kind !== "scalar") {
-        return [];
-    }
-    const getterMethod = scalarGetterMethod(field.scalar);
-    const setterMethod = scalarSetterMethod(field.scalar);
-    const typeName = scalarTsType(field.scalar);
-    const littleEndianDefault = toLittleEndianLiteral(layout);
-    const endianArg = field.byteLength === 1 || field.scalar === "bool" ? "" : ", littleEndian";
-    const getterBody = field.scalar === "bool"
-        ? `    return view.${getterMethod}(baseOffset + ${field.offset}) !== 0;`
-        : `    return view.${getterMethod}(baseOffset + ${field.offset}${endianArg});`;
-    const setterBody = field.scalar === "bool"
-        ? `    view.${setterMethod}(baseOffset + ${field.offset}, value ? 1 : 0);`
-        : `    view.${setterMethod}(baseOffset + ${field.offset}, value${endianArg});`;
-    const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
-    const indexGetterBody = field.scalar === "bool"
-        ? `    return view.${getterMethod}(${indexOffset}) !== 0;`
-        : `    return view.${getterMethod}(${indexOffset}${endianArg});`;
-    const indexSetterBody = field.scalar === "bool"
-        ? `    view.${setterMethod}(${indexOffset}, value ? 1 : 0);`
-        : `    view.${setterMethod}(${indexOffset}, value${endianArg});`;
-    const pascalName = toPascalCase(field.name);
-    return [
-        `  static get${pascalName}(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): ${typeName} {`,
-        getterBody,
-        "  }",
-        `  static set${pascalName}(view: DataView, value: ${typeName}, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {`,
-        setterBody,
-        "  }",
-        `  static get${pascalName}At(view: DataView, index: number, littleEndian = ${littleEndianDefault}): ${typeName} {`,
-        indexGetterBody,
-        "  }",
-        `  static set${pascalName}At(view: DataView, value: ${typeName}, index: number, littleEndian = ${littleEndianDefault}): void {`,
-        indexSetterBody,
-        "  }",
-        ...emitScalarSumKernel(layout, field, getterMethod, littleEndianDefault, pascalName),
-    ];
-}
-function emitScalarSumKernel(layout, field, getterMethod, littleEndianDefault, pascalName) {
-    if (!isNumberSumScalar(field.scalar)) {
-        return [];
-    }
-    const endianArg = field.byteLength === 1 ? "" : ", littleEndian";
-    return method `
-static sum${pascalName}(view: DataView, count: number, baseOffset = 0, littleEndian = ${littleEndianDefault}): number {
-  if (!Number.isInteger(count) || count < 0) {
-    throw new RangeError(\`Invalid record count: \${count}\`);
-  }
-  if (!Number.isFinite(baseOffset) || !Number.isInteger(baseOffset) || baseOffset < 0) {
-    throw new RangeError(\`Invalid base offset: \${baseOffset}\`);
-  }
-  if (count === 0) {
-    return 0;
-  }
-  const start = baseOffset + ${field.offset};
-  const limit = start + count * ${layout.byteLength};
-  const lastByte = start + (count - 1) * ${layout.byteLength} + ${field.byteLength};
-  if (lastByte > view.byteLength) {
-    throw new RangeError(\`scan range exceeds DataView length \${view.byteLength}\`);
-  }
-  let sum = 0;
-  for (let offset = start; offset < limit; offset += ${layout.byteLength}) {
-    sum += view.${getterMethod}(offset${endianArg});
-  }
-  return sum;
-}`;
-}
-function isNumberSumScalar(kind) {
-    return kind !== "i64" && kind !== "u64" && kind !== "bool";
-}
-function emitField(layout, field, options) {
-    switch (field.kind) {
-        case "scalar": {
-            const getterMethod = scalarGetterMethod(field.scalar);
-            const setterMethod = scalarSetterMethod(field.scalar);
-            const typeName = scalarTsType(field.scalar);
-            const getterArgs = field.byteLength === 1 || field.scalar === "bool" ? "" : ", this.littleEndian";
-            const instanceOffset = options.optimizeCursorOffsets
-                ? `this.$${field.name}Offset`
-                : `this.baseOffset + ${field.offset}`;
-            const getterBody = field.scalar === "bool"
-                ? `return this.view.${getterMethod}(${instanceOffset}) !== 0;`
-                : `return this.view.${getterMethod}(${instanceOffset}${getterArgs});`;
-            const setterBody = field.scalar === "bool"
-                ? `this.view.${setterMethod}(${instanceOffset}, value ? 1 : 0);`
-                : `this.view.${setterMethod}(${instanceOffset}, value${getterArgs});`;
-            return method `
-get ${field.name}(): ${typeName} {
-  ${getterBody}
-}
-set ${field.name}(value: ${typeName}) {
-  ${setterBody}
-}`;
-        }
-        case "fixed-bytes":
-            return method `
-${field.name}Bytes(): Uint8Array {
-  return fixedBytesView(this.backingBuffer(), this.backingOffset(${field.offset}), ${field.byteLength});
-}`;
-        case "fixed-string":
-            return method `
-${field.name}Text(): string {
-  return decodeFixedText(this.backingBuffer(), this.backingOffset(${field.offset}), ${field.byteLength}, ${encodingLiteral(field.encoding)});
-}
-${field.name}Bytes(): Uint8Array {
-  return fixedBytesView(this.backingBuffer(), this.backingOffset(${field.offset}), ${field.byteLength});
-}`;
-        case "dynamic-string":
-            return method `
-${field.name}View(): Utf8SpanView {
-  return new Utf8SpanView(this.view, ${field.offset}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.encoding)});
-}`;
-        case "dynamic-bytes":
-            return method `
-${field.name}View(): BytesSpanView {
-  return new BytesSpanView(this.view, ${field.offset}, this.baseOffset, this.littleEndian);
-}
-${field.name}Bytes(): Uint8Array {
-  return this.${field.name}View().bytes();
-}`;
-        case "struct":
-            return method `
-${field.name}View(): ${field.typeName}View {
-  return new ${field.typeName}View(this.view, this.absoluteOffset(${field.offset}), this.littleEndian);
-}`;
-        case "pointer": {
-            const pascalName = toPascalCase(field.name);
-            return method `
-get raw${pascalName}RelativeOffset(): number {
-  return this.view.getUint32(this.baseOffset + ${field.offset}, this.littleEndian);
-}
-get ${field.name}RelativeOffset(): number | null {
-  const rawValue = this.raw${pascalName}RelativeOffset;
-  if (rawValue === 0xffffffff) {
-    return null;
-  }
-  return this.view.getInt32(this.baseOffset + ${field.offset}, this.littleEndian);
-}
-set ${field.name}RelativeOffset(value: number | null) {
-  if (value === null) {
-    this.view.setUint32(this.baseOffset + ${field.offset}, 0xffffffff, this.littleEndian);
-    return;
-  }
-  if (!Number.isInteger(value) || value < -0x80000000 || value > 0x7fffffff || value === -1) {
-    throw new RangeError(\`pointer32 target offset must encode to signed i32 except -1: \${value}\`);
-  }
-  this.view.setInt32(this.baseOffset + ${field.offset}, value, this.littleEndian);
-}
-get unchecked${pascalName}TargetOffset(): number | null {
-  const relativeOffset = this.${field.name}RelativeOffset;
-  if (relativeOffset === null) {
-    return null;
-  }
-  return this.baseOffset + ${field.offset} + relativeOffset;
-}
-get ${field.name}TargetOffset(): number | null {
-  const targetOffset = this.unchecked${pascalName}TargetOffset;
-  if (targetOffset === null) {
-    return null;
-  }
-  ${layout.name}View.assertPointerTargetRange(this.view, targetOffset, ${field.targetTypeName}View.byteLength);
-  return targetOffset;
-}
-set unchecked${pascalName}TargetOffset(targetOffset: number | null) {
-  if (targetOffset === null) {
-    this.${field.name}RelativeOffset = null;
-    return;
-  }
-  const relativeOffset = targetOffset - (this.baseOffset + ${field.offset});
-  this.${field.name}RelativeOffset = relativeOffset;
-}
-set ${field.name}TargetOffset(targetOffset: number | null) {
-  if (targetOffset !== null) {
-    ${layout.name}View.assertPointerTargetRange(this.view, targetOffset, ${field.targetTypeName}View.byteLength);
-  }
-  this.unchecked${pascalName}TargetOffset = targetOffset;
-}
-${field.name}View(): ${field.targetTypeName}View | null {
-  const targetOffset = this.${field.name}TargetOffset;
-  if (targetOffset === null) {
-    return null;
-  }
-  const target = new ${field.targetTypeName}View(this.view, 0, this.littleEndian);
-  target.moveToOffset(targetOffset, ${field.targetTypeName}View.byteLength);
-  return target;
-}
-${field.name}Into(out: ${field.targetTypeName}View): boolean {
-  const targetOffset = this.${field.name}TargetOffset;
-  if (targetOffset === null) {
-    return false;
-  }
-  out.moveToOffset(targetOffset, ${field.targetTypeName}View.byteLength);
-  return true;
-}`;
-        }
-        case "fixed-array":
-            return emitFixedArrayFieldAccessor(field, encodingLiteral);
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    return method `
-${field.name}View(): ScalarVectorView<${scalarTsType(field.element.scalar)}> {
-  return new ScalarVectorView(this.view, ${field.offset}, "${field.element.scalar}", this.baseOffset, this.littleEndian);
-}`;
-                case "dynamic-string":
-                    return method `
-${field.name}View(): Utf8VectorView {
-  return new Utf8VectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
-}`;
-                case "dynamic-bytes":
-                    return method `
-${field.name}View(): BytesVectorView {
-  return new BytesVectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian);
-}`;
-                case "fixed-bytes":
-                    return method `
-${field.name}View(): FixedBytesVectorView {
-  return new FixedBytesVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian);
-}`;
-                case "fixed-string":
-                    return method `
-${field.name}View(): FixedStringVectorView {
-  return new FixedStringVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
-}`;
-                case "struct":
-                    return method `
-${field.name}View(): StructVectorView<${field.element.typeName}View> {
-  return new StructVectorView(this.view, ${field.offset}, ${field.element.byteLength}, (view, baseOffset, littleEndian) => new ${field.element.typeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
-}`;
-                case "pointer":
-                    return method `
-${field.name}View(): PointerVectorView<${field.element.targetTypeName}View> {
-  return new PointerVectorView(this.view, ${field.offset}, ${field.element.targetTypeName}View.byteLength, (view, baseOffset, littleEndian) => new ${field.element.targetTypeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
-}`;
-            }
-    }
-}
-function toPascalCase(name) {
-    return name.slice(0, 1).toUpperCase() + name.slice(1);
-}
-function toLittleEndianLiteral(layout) {
-    return layout.endianness === "little" ? "true" : "false";
-}
-function encodingLiteral(encoding) {
-    return encoding === "ascii" ? "\"ascii\"" : "\"utf8\"";
-}
-function hasTailWriterFields(layout, layoutMap) {
-    return layout.fields.some((field) => isTailWriterField(field, layoutMap));
-}
-function isTailWriterField(field, layoutMap) {
-    switch (field.kind) {
-        case "dynamic-string":
-        case "dynamic-bytes":
-            return true;
-        case "vector":
-            return (field.element.kind === "scalar" ||
-                field.element.kind === "fixed-bytes" ||
-                field.element.kind === "fixed-string" ||
-                field.element.kind === "dynamic-string" ||
-                field.element.kind === "dynamic-bytes" ||
-                field.element.kind === "pointer" ||
-                canWriteStructVectorElement(field.element, layoutMap));
-        default:
-            return false;
-    }
-}
-function canEmitObjectWriter(layout, layoutMap) {
-    return layout.fields.every((field) => canWriteObjectField(field, layoutMap));
-}
-function canWriteObjectField(field, layoutMap) {
-    switch (field.kind) {
-        case "scalar":
-        case "fixed-bytes":
-        case "fixed-string":
-        case "dynamic-string":
-        case "dynamic-bytes":
-        case "struct":
-        case "pointer":
-            return true;
-        case "fixed-array":
-            return (field.element.kind !== "struct" ||
-                canWriteFixedArrayStructElement(field.element, layoutMap, hasTailWriterFields));
-        case "vector":
-            return (field.element.kind !== "struct" ||
-                canWriteStructVectorElement(field.element, layoutMap));
-    }
-}
-function canWriteStructVectorElement(element, layoutMap) {
-    if (element.kind !== "struct") {
-        return false;
-    }
-    const elementLayout = layoutMap.get(element.typeName);
-    return elementLayout !== undefined && !hasTailWriterFields(elementLayout, layoutMap);
+function emitLayerBlock(lines) {
+    return lines.length === 0 ? [] : [...lines, ""];
 }
 //# sourceMappingURL=emitter.js.map