@scoova/mgl 1.0.0

package/build/generate-docs.ts

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import path from 'path';
+import typedocConfig from '../typedoc.json' with {type: 'json'};
+import packageJson from '../package.json' with {type: 'json'};
+import {get} from 'https';
+
+type HtmlDoc = {
+    title: string;
+    description: string;
+    mdFileName: string;
+}
+
+function generateAPIIntroMarkdown(lines: string[]): string {
+    let intro = `# Intro
+
+This file is intended as a reference for the important and public classes of this API.
+We recommend looking at the [examples](../examples/index.md) as they will help you the most to start with MapLibre.
+
+Most of the classes written here have an "Options" object for initialization, it is recommended to check which options exist.
+
+It is recommended to import what you need and the use it. Some examples for classes assume you did that.
+For example, import the \`Map\` class like this:
+\`\`\`ts
+import {Map} from 'maplibre-gl';
+const map = new Map(...)
+\`\`\`
+
+Import declarations are omitted from the examples for brevity.
+
+`;
+    intro += lines.map(l => l.replace('../', './')).join('\n');
+    return intro;
+}
+
+function generateMarkdownForExample(title: string, description: string, file: string, htmlContent: string): string {
+    return `
+# ${title}
+
+${description}
+
+<iframe src="../${file}" width="100%" style="border:none; height:400px"></iframe>
+
+\`\`\`html
+${htmlContent}
+\`\`\`
+`;
+}
+
+function generateMarkdownIndexFileOfAllExamples(indexArray: HtmlDoc[]): string {
+    let indexMarkdown = '# Overview \n\n';
+    for (const indexArrayItem of indexArray) {
+        indexMarkdown += `
+## [${indexArrayItem.title}](./${indexArrayItem.mdFileName})
+
+![${indexArrayItem.description}](../assets/examples/${indexArrayItem.mdFileName!.replace('.md', '.png')}){ loading=lazy }
+
+${indexArrayItem.description}
+`;
+    }
+    return indexMarkdown;
+}
+
+/**
+ * Builds the README.md file by parsing the modules.md file generated by typedoc.
+ */
+function generateReadme() {
+    const globalsFile = path.join(typedocConfig.out, 'globals.md');
+    const content = fs.readFileSync(globalsFile, 'utf-8');
+    let lines = content.split('\n');
+    const classesLineIndex = lines.indexOf(lines.find(l => l.endsWith('Classes')) as string);
+    lines = lines.splice(2, classesLineIndex - 2);
+    const contentString = generateAPIIntroMarkdown(lines);
+    fs.writeFileSync(path.join(typedocConfig.out, 'README.md'), contentString);
+    fs.rmSync(globalsFile);
+}
+
+/**
+ * This takes the examples folder with all the html files and generates a markdown file for each of them.
+ * It also create an index file with all the examples and their images.
+ */
+function generateExamplesFolder() {
+    const examplesDocsFolder = path.join('docs', 'examples');
+    if (fs.existsSync(examplesDocsFolder)) {
+        fs.rmSync(examplesDocsFolder, {recursive: true, force: true});
+    }
+    fs.mkdirSync(examplesDocsFolder);
+    const examplesFolder = path.join('test', 'examples');
+    const files = fs.readdirSync(examplesFolder).filter(f => f.endsWith('html'));
+    const maplibreUnpkg = `https://unpkg.com/maplibre-gl@${packageJson.version}/`;
+    const indexArray = [] as HtmlDoc[];
+    for (const file of files) {
+        const htmlFile = path.join(examplesFolder, file);
+        let htmlContent = fs.readFileSync(htmlFile, 'utf-8');
+        htmlContent = htmlContent.replace(/\.\.\/\.\.\//g, maplibreUnpkg);
+        htmlContent = htmlContent.replace(/-dev.js/g, '.js');
+        const htmlContentLines = htmlContent.split('\n');
+        const title = htmlContentLines.find(l => l.includes('<title'))?.replace('<title>', '').replace('</title>', '').trim()!;
+        const description = htmlContentLines.find(l => l.includes('og:description'))?.replace(/.*content=\"(.*)\".*/, '$1')!;
+        fs.writeFileSync(path.join(examplesDocsFolder, file), htmlContent);
+        const mdFileName = file.replace('.html', '.md');
+        indexArray.push({
+            title,
+            description,
+            mdFileName
+        });
+        const exampleMarkdown = generateMarkdownForExample(title, description, file, htmlContent);
+        fs.writeFileSync(path.join(examplesDocsFolder, mdFileName), exampleMarkdown);
+    }
+
+    const indexMarkdown = generateMarkdownIndexFileOfAllExamples(indexArray);
+    fs.writeFileSync(path.join(examplesDocsFolder, 'index.md'), indexMarkdown);
+}
+
+async function fetchUrlContent(url: string) {
+    return new Promise<string>((resolve, reject) => {
+        get(url, (res) => {
+            let data = '';
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+                reject(new Error(res.statusMessage));
+                return;
+            }
+
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                resolve(data);
+            });
+        }).on('error', reject);
+    });
+}
+
+async function generatePluginsPage() {
+    /**
+     * It extract some sections from Awesome MapLibre README.md so we can integrate it into our plugins page
+     *
+     * ```
+     *    header
+     *    <!-- [SOME-ID]:BEGIN -->
+     *    CONTENT-TO-EXTRACT
+     *    <!-- [SOME-ID]:END -->
+     *    footer
+     * ```
+     */
+    const awesomeReadmeUrl = 'https://raw.githubusercontent.com/maplibre/awesome-maplibre/main/README.md';
+    const awesomeReadme = await fetchUrlContent(awesomeReadmeUrl);
+
+    const contentGroupsRE = /<!--\s*\[([-a-zA-Z]+)\]:BEGIN\s*-->([\s\S]*?)<!--\s*\[\1\]:END\s*-->/g;
+
+    const matches = awesomeReadme.matchAll(contentGroupsRE);
+    const groups = Object.fromEntries(
+        Array.from(matches).map(([, key, content]) => [key, content])
+    );
+
+    const pluginsContent = `# Plugins
+
+${groups['JAVASCRIPT-PLUGINS']}
+
+## Framework Integrations
+
+${groups['JAVASCRIPT-BINDINGS']}
+`;
+
+    fs.writeFileSync('docs/plugins.md', pluginsContent, {encoding: 'utf-8'});
+}
+
+function updateMapLibreVersionForUNPKG() {
+
+    // Read index.md
+    const indexPath = 'docs/index.md';
+    let indexContent = fs.readFileSync(indexPath, 'utf-8');
+
+    // Replace the version number
+    indexContent = indexContent.replace(/unpkg\.com\/maplibre-gl@\^(\d+\.\d+\.\d+)/g, `unpkg.com/maplibre-gl@^${packageJson.version}`);
+
+    // Save index.md
+    fs.writeFileSync(indexPath, indexContent);
+}
+
+// !!Main flow start here!!
+if (!fs.existsSync(typedocConfig.out)) {
+    throw new Error('Please run typedoc generation first!');
+}
+fs.rmSync(path.join(typedocConfig.out, 'README.md'));
+generateReadme();
+generateExamplesFolder();
+await generatePluginsPage();
+updateMapLibreVersionForUNPKG();
+console.log('Docs generation completed, to see it in action run\n npm run start-docs');

package/build/generate-shaders.ts

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import {globSync} from 'glob';
+import path from 'path';
+
+console.log('Generating shaders');
+
+/**
+ * This script is intended to copy the glsl file to the compilation output folder,
+ * change their extension to .js and export the shaders as strings in javascript.
+ * It will also minify them a bit if needed and change the extension to .js
+ * After that it will create a combined typescript definition file and manipulate it a bit
+ * It will also create a simple package.json file to allow importing this package in webpack
+ */
+
+const vertex = globSync('./src/shaders/*.vertex.glsl');
+for (const file of vertex) {
+    const code = fs.readFileSync(file, 'utf8');
+    const content = glslToTs(code, 'vertex');
+    const fileName = path.join('.', 'src', 'shaders', `${file.split(path.sep).splice(-1)}.g.ts`);
+    fs.writeFileSync(fileName, content);
+}
+
+console.log(`Finished converting ${vertex.length} vertex shaders`);
+
+const fragment = globSync('./src/shaders/*.fragment.glsl');
+for (const file of fragment) {
+    const code = fs.readFileSync(file, 'utf8');
+    const content = glslToTs(code, 'fragment');
+    const fileName = path.join('.', 'src', 'shaders', `${file.split(path.sep).splice(-1)}.g.ts`);
+    fs.writeFileSync(fileName, content);
+}
+
+console.log(`Finished converting ${fragment.length} fragment shaders`);
+
+function glslToTs(code: string, type: 'fragment'|'vertex'): string {
+    code = code
+        .trim(); // strip whitespace at the start/end
+
+    // WebGL1 Compat -- Start
+
+    if (type === 'fragment') {
+        code = code
+            .replace(/\bin\s/g, 'varying ') // For fragment shaders, replace "in " with "varying "
+            .replace('out highp vec4 fragColor;', '');
+    }
+
+    if (type === 'vertex') {
+        code = code
+            .replace(/\bin\s/g, 'attribute ') // For vertex shaders, replace "in " with "attribute "
+            .replace(/\bout\s/g, 'varying '); // For vertex shaders, replace "out " with "varying "
+    }
+
+    code = code
+        .replace(/fragColor/g, 'gl_FragColor')
+        .replace(/texture\(/g, 'texture2D(');
+
+    // WebGL1 Compat -- End
+
+    code = code
+        .replace(/\s*\/\/[^\n]*\n/g, '\n') // strip double-slash comments
+        .replace(/\n+/g, '\n') // collapse multi line breaks
+        .replace(/\n\s+/g, '\n') // strip indentation
+        .replace(/\s?([+-\/*=,])\s?/g, '$1') // strip whitespace around operators
+        .replace(/([;\(\),\{\}])\n(?=[^#])/g, '$1'); // strip more line breaks
+
+    return `// This file is generated. Edit build/generate-shaders.ts, then run \`npm run codegen\`.
+export default ${JSON.stringify(code).replaceAll('"', '\'')};\n`;
+}

package/build/generate-struct-arrays.ts

@@ -0,0 +1,438 @@
+/*
+ * Generates the following:
+ *  - data/array_types.js, which consists of:
+ *    - StructArrayLayout_* subclasses, one for each underlying memory layout we need
+ *    - Named exports mapping each conceptual array type (e.g., CircleLayoutArray) to its corresponding StructArrayLayout class
+ *    - Particular, named StructArray subclasses, when fancy struct accessors are needed (e.g. CollisionBoxArray)
+ */
+
+'use strict';
+
+import * as fs from 'fs';
+import * as util from '../src/util/util';
+import {createLayout, viewTypes} from '../src/util/struct_array';
+import type {ViewType, StructArrayLayout} from '../src/util/struct_array';
+
+import posAttributes from '../src/data/pos_attributes';
+import pos3dAttributes from '../src/data/pos3d_attributes';
+import rasterBoundsAttributes from '../src/data/raster_bounds_attributes';
+import circleAttributes from '../src/data/bucket/circle_attributes';
+import fillAttributes from '../src/data/bucket/fill_attributes';
+import fillExtrusionAttributes from '../src/data/bucket/fill_extrusion_attributes';
+import {lineLayoutAttributes} from '../src/data/bucket/line_attributes';
+import {lineLayoutAttributesExt} from '../src/data/bucket/line_attributes_ext';
+import {patternAttributes} from '../src/data/bucket/pattern_attributes';
+// symbol layer specific arrays
+import {
+    symbolLayoutAttributes,
+    dynamicLayoutAttributes,
+    placementOpacityAttributes,
+    collisionBox,
+    collisionBoxLayout,
+    collisionCircleLayout,
+    collisionVertexAttributes,
+    quadTriangle,
+    placement,
+    symbolInstance,
+    glyphOffset,
+    lineVertex,
+    textAnchorOffset
+} from '../src/data/bucket/symbol_attributes';
+
+const typeAbbreviations = {
+    'Int8': 'b',
+    'Uint8': 'ub',
+    'Int16': 'i',
+    'Uint16': 'ui',
+    'Int32': 'l',
+    'Uint32': 'ul',
+    'Float32': 'f'
+};
+
+const arraysWithStructAccessors = [];
+const arrayTypeEntries = new Set();
+const layoutCache = {};
+
+function normalizeMembers(members, usedTypes) {
+    return members.map((member) => {
+        if (usedTypes && !usedTypes.has(member.type)) {
+            usedTypes.add(member.type);
+        }
+
+        return util.extend(member, {
+            size: sizeOf(member.type),
+            view: member.type.toLowerCase()
+        });
+    });
+}
+
+// - If necessary, write the StructArrayLayout_* class for the given layout
+// - If `includeStructAccessors`, write the fancy subclass
+// - Add an entry for `name` in the array type registry
+function createStructArrayType(name: string, layout: StructArrayLayout, includeStructAccessors: boolean = false) {
+    const hasAnchorPoint = layout.members.some(m => m.name === 'anchorPointX');
+
+    // create the underlying StructArrayLayout class exists
+    const layoutClass = createStructArrayLayoutType(layout);
+    const arrayClass = `${camelize(name)}Array`;
+
+    if (includeStructAccessors) {
+        const usedTypes = new Set(['Uint8']);
+        const members = normalizeMembers(layout.members, usedTypes);
+        arraysWithStructAccessors.push({
+            arrayClass,
+            members,
+            size: layout.size,
+            usedTypes,
+            hasAnchorPoint,
+            layoutClass,
+            includeStructAccessors
+        });
+    } else {
+        arrayTypeEntries.add(`export class ${arrayClass} extends ${layoutClass} {}`);
+    }
+}
+
+function createStructArrayLayoutType({members, size, alignment}) {
+    const usedTypes = new Set(['Uint8']);
+    members = normalizeMembers(members, usedTypes);
+
+    // combine consecutive 'members' with same underlying type, summing their
+    // component counts
+    if (!alignment || alignment === 1) members = members.reduce((memo, member) => {
+        if (memo.length > 0 && memo[memo.length - 1].type === member.type) {
+            const last = memo[memo.length - 1];
+            return memo.slice(0, -1).concat(util.extend({}, last, {
+                components: last.components + member.components,
+            }));
+        }
+        return memo.concat(member);
+    }, []);
+
+    const key = `${members.map(m => `${m.components}${typeAbbreviations[m.type]}`).join('')}${size}`;
+    const className = `StructArrayLayout${key}`;
+
+    if (!layoutCache[key]) {
+        layoutCache[key] = {
+            className,
+            members,
+            size,
+            usedTypes
+        };
+    }
+
+    return className;
+}
+
+function sizeOf(type: ViewType): number {
+    return viewTypes[type].BYTES_PER_ELEMENT;
+}
+
+function camelize (str) {
+    return str.replace(/(?:^|[-_])(.)/g, (_, x) => {
+        return /^[0-9]$/.test(x) ? _ : x.toUpperCase();
+    });
+}
+
+createStructArrayType('pos', posAttributes);
+createStructArrayType('pos3d', pos3dAttributes);
+createStructArrayType('raster_bounds', rasterBoundsAttributes);
+
+// layout vertex arrays
+const layoutAttributes = {
+    circle: circleAttributes,
+    fill: fillAttributes,
+    'fill-extrusion': fillExtrusionAttributes,
+    heatmap: circleAttributes,
+    line: lineLayoutAttributes,
+    lineExt: lineLayoutAttributesExt,
+    pattern: patternAttributes
+};
+for (const name in layoutAttributes) {
+    createStructArrayType(`${name.replace(/-/g, '_')}_layout`, layoutAttributes[name]);
+}
+
+createStructArrayType('symbol_layout', symbolLayoutAttributes);
+createStructArrayType('symbol_dynamic_layout', dynamicLayoutAttributes);
+createStructArrayType('symbol_opacity', placementOpacityAttributes);
+createStructArrayType('collision_box', collisionBox, true);
+createStructArrayType('collision_box_layout', collisionBoxLayout);
+createStructArrayType('collision_circle_layout', collisionCircleLayout);
+createStructArrayType('collision_vertex', collisionVertexAttributes);
+createStructArrayType('quad_triangle', quadTriangle);
+createStructArrayType('placed_symbol', placement, true);
+createStructArrayType('symbol_instance', symbolInstance, true);
+createStructArrayType('glyph_offset', glyphOffset, true);
+createStructArrayType('symbol_line_vertex', lineVertex, true);
+createStructArrayType('text_anchor_offset', textAnchorOffset, true);
+
+// feature index array
+createStructArrayType('feature_index', createLayout([
+    // the index of the feature in the original vectortile
+    {type: 'Uint32', name: 'featureIndex'},
+    // the source layer the feature appears in
+    {type: 'Uint16', name: 'sourceLayerIndex'},
+    // the bucket the feature appears in
+    {type: 'Uint16', name: 'bucketIndex'}
+]), true);
+
+// triangle index array
+createStructArrayType('triangle_index', createLayout([
+    {type: 'Uint16', name: 'vertices', components: 3}
+]));
+
+// line index array
+createStructArrayType('line_index', createLayout([
+    {type: 'Uint16', name: 'vertices', components: 2}
+]));
+
+// line strip index array
+createStructArrayType('line_strip_index', createLayout([
+    {type: 'Uint16', name: 'vertices', components: 1}
+]));
+
+// paint vertex arrays
+
+// used by SourceBinder for float properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 1
+}], 4));
+
+// used by SourceBinder for color properties and CompositeBinder for float properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 2
+}], 4));
+
+// used by CompositeBinder for color properties
+createStructArrayLayoutType(createLayout([{
+    name: 'dummy name (unused for StructArrayLayout)',
+    type: 'Float32',
+    components: 4
+}], 4));
+
+const layouts = Object.keys(layoutCache).map(k => layoutCache[k]);
+
+function emitStructArrayLayout(locals) {
+    const output = [];
+    const {
+        className,
+        members,
+        size,
+        usedTypes
+    } = locals;
+    const structArrayLayoutClass = className;
+
+    output.push(
+        `/**
+ * @internal
+ * Implementation of the StructArray layout:`);
+
+    for (const member of members) {
+        output.push(
+            ` * [${member.offset}] - ${member.type}[${member.components}]`);
+    }
+
+    output.push(
+        ` *
+ */
+class ${structArrayLayoutClass} extends StructArray {`);
+
+    for (const type of usedTypes) {
+        output.push(
+            `    ${type.toLowerCase()}: ${type}Array;`);
+    }
+
+    output.push(`
+    _refreshViews() {`);
+
+    for (const type of usedTypes) {
+        output.push(
+            `        this.${type.toLowerCase()} = new ${type}Array(this.arrayBuffer);`);
+    }
+
+    output.push(
+        '    }');
+
+    // prep for emplaceBack: collect type sizes and count the number of arguments
+    // we'll need
+    const bytesPerElement = size;
+    const usedTypeSizes = [];
+    const argNames = [];
+    const argNamesTyped = [];
+
+    for (const member of members) {
+        if (usedTypeSizes.indexOf(member.size) < 0) {
+            usedTypeSizes.push(member.size);
+        }
+        for (let c = 0; c < member.components; c++) {
+            // arguments v0, v1, v2, ... are, in order, the components of
+            // member 0, then the components of member 1, etc.
+            const name = `v${argNames.length}`;
+            argNames.push(name);
+            argNamesTyped.push(`${name}: number`);
+        }
+    }
+
+    output.push(
+        `
+    public emplaceBack(${argNamesTyped.join(', ')}) {
+        const i = this.length;
+        this.resize(i + 1);
+        return this.emplace(i, ${argNames.join(', ')});
+    }
+
+    public emplace(i: number, ${argNamesTyped.join(', ')}) {`);
+
+    for (const size of usedTypeSizes) {
+        output.push(
+            `        const o${size.toFixed(0)} = i * ${(bytesPerElement / size).toFixed(0)};`);
+    }
+
+    let argIndex = 0;
+    for (const member of members) {
+        for (let c = 0; c < member.components; c++) {
+            // The index for `member` component `c` into the appropriate type array is:
+            // this.{TYPE}[o{SIZE} + MEMBER_OFFSET + {c}] = v{X}
+            // where MEMBER_OFFSET = ROUND(member.offset / size) is the per-element
+            // offset of this member into the array
+            const index = `o${member.size.toFixed(0)} + ${(member.offset / member.size + c).toFixed(0)}`;
+
+            output.push(
+                `        this.${member.view}[${index}] = v${argIndex++};`);
+        }
+    }
+
+    output.push(
+        `        return i;
+    }
+}
+
+${structArrayLayoutClass}.prototype.bytesPerElement = ${size};
+register('${structArrayLayoutClass}', ${structArrayLayoutClass});
+`);
+
+    return output.join('\n');
+}
+
+function emitStructArray(locals) {
+    const output = [];
+    const {
+        arrayClass,
+        members,
+        size,
+        hasAnchorPoint,
+        layoutClass,
+        includeStructAccessors
+    } = locals;
+
+    const structTypeClass = arrayClass.replace('Array', 'Struct');
+    const structArrayClass = arrayClass;
+    const structArrayLayoutClass = layoutClass;
+
+    // collect components
+    const components = [];
+    for (const member of members) {
+        for (let c = 0; c < member.components; c++) {
+            let name = member.name;
+            if (member.components > 1) {
+                name += c;
+            }
+            components.push({name, member, component: c});
+        }
+    }
+
+    // exceptions for which we generate accessors on the array rather than a separate struct for performance
+    const useComponentGetters = structArrayClass === 'GlyphOffsetArray' || structArrayClass === 'SymbolLineVertexArray';
+
+    if (includeStructAccessors && !useComponentGetters) {
+        output.push(
+            `/** @internal */
+class ${structTypeClass} extends Struct {
+    _structArray: ${structArrayClass};`);
+
+        for (const {name, member, component} of components) {
+            const elementOffset = `this._pos${member.size.toFixed(0)}`;
+            const componentOffset = (member.offset / member.size + component).toFixed(0);
+            const index = `${elementOffset} + ${componentOffset}`;
+            const componentAccess = `this._structArray.${member.view}[${index}]`;
+
+            output.push(
+                `    get ${name}() { return ${componentAccess}; }`);
+
+            // generate setters for properties that are updated during runtime symbol placement; others are read-only
+            if (name === 'crossTileID' || name === 'placedOrientation' || name === 'hidden') {
+                output.push(
+                    `    set ${name}(x: number) { ${componentAccess} = x; }`);
+            }
+        }
+
+        // Special case used for the CollisionBoxArray type
+        if (hasAnchorPoint) {
+            output.push(
+                '    get anchorPoint() { return new Point(this.anchorPointX, this.anchorPointY); }');
+        }
+
+        output.push(
+            `}
+
+${structTypeClass}.prototype.size = ${size};
+
+export type ${structTypeClass.replace('Struct', '')} = ${structTypeClass};
+`);
+    } // end 'if (includeStructAccessors)'
+
+    output.push(
+        `/** @internal */
+export class ${structArrayClass} extends ${structArrayLayoutClass} {`);
+
+    if (useComponentGetters) {
+        for (const member of members) {
+            for (let c = 0; c < member.components; c++) {
+                if (!includeStructAccessors) continue;
+                let name = `get${member.name}`;
+                if (member.components > 1) {
+                    name += c;
+                }
+                const componentOffset = (member.offset / member.size + c).toFixed(0);
+                const componentStride = size / member.size;
+                output.push(
+                    `    ${name}(index: number) { return this.${member.view}[index * ${componentStride} + ${componentOffset}]; }`);
+            }
+        }
+    } else if (includeStructAccessors) { // get(i)
+        output.push(
+            `    /**
+     * Return the ${structTypeClass} at the given location in the array.
+     * @param index The index of the element.
+     */
+    get(index: number): ${structTypeClass} {
+        return new ${structTypeClass}(this, index);
+    }`);
+    }
+    output.push(
+        `}
+
+register('${structArrayClass}', ${structArrayClass});
+`);
+
+    return output.join('\n');
+}
+
+fs.writeFileSync('src/data/array_types.g.ts',
+    `// This file is generated. Edit build/generate-struct-arrays.ts, then run \`npm run codegen\`.
+
+import {Struct, StructArray} from '../util/struct_array';
+import {register} from '../util/web_worker_transfer';
+import Point from '@mapbox/point-geometry';
+
+${layouts.map(emitStructArrayLayout).join('\n')}
+${arraysWithStructAccessors.map(emitStructArray).join('\n')}
+${[...arrayTypeEntries].join('\n')}
+export {
+    ${layouts.map(layout => layout.className).join(',\n    ')}
+};
+`);