quicktype 18.0.5 → 19.0.4

package/dist/quicktype-core/Naming.js

@@ -1,356 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assignNames = exports.keywordNamespace = exports.DependencyName = exports.AssociatedName = exports.SimpleName = exports.FixedName = exports.Name = exports.funPrefixNamer = exports.Namer = exports.Namespace = void 0;
-const collection_utils_1 = require("collection-utils");
-const Support_1 = require("./support/Support");
-class Namespace {
-    forbiddenNamespaces;
-    additionalForbidden;
-    _children = new Set();
-    _members = new Set();
-    constructor(_name, parent, forbiddenNamespaces, additionalForbidden) {
-        this.forbiddenNamespaces = new Set(forbiddenNamespaces);
-        this.additionalForbidden = new Set(additionalForbidden);
-        if (parent !== undefined) {
-            parent.addChild(this);
-        }
-    }
-    addChild(child) {
-        this._children.add(child);
-    }
-    get children() {
-        return this._children;
-    }
-    get members() {
-        return this._members;
-    }
-    get forbiddenNameds() {
-        // FIXME: cache
-        return (0, collection_utils_1.setUnion)(this.additionalForbidden, ...Array.from(this.forbiddenNamespaces).map(ns => ns.members));
-    }
-    add(named) {
-        this._members.add(named);
-        return named;
-    }
-}
-exports.Namespace = Namespace;
-// `Namer`s are invoked to figure out what names to assign non-fixed `Name`s,
-// and in particular to resolve conflicts.  Those arise under two circumstances,
-// which can also combine:
-//
-// 1. A proposed name is the same as an already assigned name that's forbidden
-//    for the name to be assigned.
-// 2. There is more than one `Name` about to be assigned a name that all have
-//    the same proposed name.
-//
-// The namer is invoked with the set of all assigned, forbidden names,
-// the requested name, and the `Name`s to assign names to.
-//
-// `Namer` is a class so that we can compare namers and put them into immutable
-// collections.
-class Namer {
-    name;
-    nameStyle;
-    _prefixes;
-    constructor(name, nameStyle, prefixes) {
-        this.name = name;
-        this.nameStyle = nameStyle;
-        this._prefixes = new Set(prefixes);
-    }
-    // The namesIterable comes directly out of the context and will
-    // be modified if we assign
-    assignNames(names, forbiddenNamesIterable, namesToAssignIterable) {
-        const forbiddenNames = new Set(forbiddenNamesIterable);
-        const namesToAssign = Array.from(namesToAssignIterable);
-        (0, Support_1.assert)(namesToAssign.length > 0, "Number of names can't be less than 1");
-        const allAssignedNames = new Map();
-        let namesToPrefix = [];
-        for (const name of namesToAssign) {
-            const proposedNames = name.proposeUnstyledNames(names);
-            const namingFunction = name.namingFunction;
-            // Find the first proposed name that isn't proposed by
-            // any of the other names and that isn't already forbidden.
-            const maybeUniqueName = (0, collection_utils_1.iterableFind)(proposedNames, proposed => !forbiddenNames.has(namingFunction.nameStyle(proposed)) &&
-                namesToAssign.every(n => n === name || !n.proposeUnstyledNames(names).has(proposed)));
-            if (maybeUniqueName !== undefined) {
-                const styledName = namingFunction.nameStyle(maybeUniqueName);
-                const assigned = name.nameAssignments(forbiddenNames, styledName);
-                if (assigned !== null) {
-                    (0, collection_utils_1.mapMergeInto)(allAssignedNames, assigned);
-                    (0, collection_utils_1.setUnionInto)(forbiddenNames, assigned.values());
-                    continue;
-                }
-            }
-            // There's no unique name, or it couldn't be assigned, so
-            // we need to prefix-name this one.
-            namesToPrefix.push(name);
-        }
-        let prefixes = this._prefixes.values();
-        let suffixNumber = 1;
-        for (const name of namesToPrefix) {
-            const originalName = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(name.proposeUnstyledNames(names)));
-            for (;;) {
-                let nameToTry;
-                const { done, value: prefix } = prefixes.next();
-                if (!done) {
-                    nameToTry = `${prefix}_${originalName}`;
-                }
-                else {
-                    nameToTry = `${originalName}_${suffixNumber.toString()}`;
-                    suffixNumber++;
-                }
-                const styledName = name.namingFunction.nameStyle(nameToTry);
-                const assigned = name.nameAssignments(forbiddenNames, styledName);
-                if (assigned === null)
-                    continue;
-                (0, collection_utils_1.mapMergeInto)(allAssignedNames, assigned);
-                (0, collection_utils_1.setUnionInto)(forbiddenNames, assigned.values());
-                break;
-            }
-        }
-        return allAssignedNames;
-    }
-}
-exports.Namer = Namer;
-const funPrefixes = [
-    "Purple",
-    "Fluffy",
-    "Tentacled",
-    "Sticky",
-    "Indigo",
-    "Indecent",
-    "Hilarious",
-    "Ambitious",
-    "Cunning",
-    "Magenta",
-    "Frisky",
-    "Mischievous",
-    "Braggadocious"
-];
-function funPrefixNamer(name, nameStyle) {
-    return new Namer(name, nameStyle, funPrefixes);
-}
-exports.funPrefixNamer = funPrefixNamer;
-// FIXME: I think the type hierarchy is somewhat wrong here.  `FixedName`
-// should be a `Name`, but the non-fixed names should probably have their
-// own common superclass.  Most methods of `Name` make sense only either
-// for `FixedName` or the non-fixed names.
-class Name {
-    _namingFunction;
-    order;
-    _associates = new Set();
-    // If a Named is fixed, the namingFunction is undefined.
-    constructor(_namingFunction, order) {
-        this._namingFunction = _namingFunction;
-        this.order = order;
-    }
-    addAssociate(associate) {
-        this._associates.add(associate);
-    }
-    isFixed() {
-        return this instanceof FixedName;
-    }
-    get namingFunction() {
-        return (0, Support_1.defined)(this._namingFunction);
-    }
-    firstProposedName(names) {
-        return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(this.proposeUnstyledNames(names)));
-    }
-    nameAssignments(forbiddenNames, assignedName) {
-        if (forbiddenNames.has(assignedName))
-            return null;
-        const assignments = new Map([[this, assignedName]]);
-        for (const an of this._associates) {
-            const associatedAssignedName = an.getName(assignedName);
-            if (forbiddenNames.has(associatedAssignedName)) {
-                return null;
-            }
-            assignments.set(an, associatedAssignedName);
-        }
-        return assignments;
-    }
-}
-exports.Name = Name;
-// FIXME: FixedNameds should optionally be user-configurable
-class FixedName extends Name {
-    _fixedName;
-    constructor(_fixedName) {
-        super(undefined, 0);
-        this._fixedName = _fixedName;
-    }
-    get dependencies() {
-        return [];
-    }
-    addAssociate(_) {
-        return (0, Support_1.panic)("Cannot add associates to fixed names");
-    }
-    get fixedName() {
-        return this._fixedName;
-    }
-    proposeUnstyledNames(_) {
-        return (0, Support_1.panic)("Only fixedName should be called on FixedName.");
-    }
-}
-exports.FixedName = FixedName;
-class SimpleName extends Name {
-    _unstyledNames;
-    constructor(unstyledNames, namingFunction, order) {
-        super(namingFunction, order);
-        this._unstyledNames = new Set(unstyledNames);
-    }
-    get dependencies() {
-        return [];
-    }
-    proposeUnstyledNames(_) {
-        return this._unstyledNames;
-    }
-}
-exports.SimpleName = SimpleName;
-class AssociatedName extends Name {
-    _sponsor;
-    getName;
-    constructor(_sponsor, order, getName) {
-        super(undefined, order);
-        this._sponsor = _sponsor;
-        this.getName = getName;
-    }
-    get dependencies() {
-        return [this._sponsor];
-    }
-    proposeUnstyledNames(_) {
-        return (0, Support_1.panic)("AssociatedName must be assigned via its sponsor");
-    }
-}
-exports.AssociatedName = AssociatedName;
-class DependencyName extends Name {
-    _proposeUnstyledName;
-    _dependencies;
-    constructor(namingFunction, order, _proposeUnstyledName) {
-        super(namingFunction, order);
-        this._proposeUnstyledName = _proposeUnstyledName;
-        const dependencies = [];
-        _proposeUnstyledName(n => {
-            dependencies.push(n);
-            return "0xDEADBEEF";
-        });
-        this._dependencies = new Set(dependencies);
-    }
-    get dependencies() {
-        return Array.from(this._dependencies);
-    }
-    proposeUnstyledNames(names) {
-        return new Set([
-            this._proposeUnstyledName(n => {
-                (0, Support_1.assert)(this._dependencies.has(n), "DependencyName proposer is not pure");
-                return (0, Support_1.defined)(names.get(n));
-            })
-        ]);
-    }
-}
-exports.DependencyName = DependencyName;
-function keywordNamespace(name, keywords) {
-    const ns = new Namespace(name, undefined, [], []);
-    for (const kw of keywords) {
-        ns.add(new FixedName(kw));
-    }
-    return ns;
-}
-exports.keywordNamespace = keywordNamespace;
-function allNamespacesRecursively(namespaces) {
-    return (0, collection_utils_1.setUnion)(namespaces, ...Array.from((0, collection_utils_1.setMap)(namespaces, ns => allNamespacesRecursively(ns.children))));
-}
-class NamingContext {
-    _names = new Map();
-    _namedsForName = new Map();
-    namespaces;
-    constructor(rootNamespaces) {
-        this.namespaces = allNamespacesRecursively(rootNamespaces);
-    }
-    get names() {
-        return this._names;
-    }
-    isReadyToBeNamed = (named) => {
-        if (this._names.has(named))
-            return false;
-        return named.dependencies.every((n) => this._names.has(n));
-    };
-    areForbiddensFullyNamed(namespace) {
-        return (0, collection_utils_1.iterableEvery)(namespace.forbiddenNameds, n => this._names.has(n));
-    }
-    isConflicting = (namedNamespace, proposed) => {
-        const namedsForProposed = this._namedsForName.get(proposed);
-        // If the name is not assigned at all, there is no conflict.
-        if (namedsForProposed === undefined)
-            return false;
-        // The name is assigned, but it might still not be forbidden.
-        for (const n of namedsForProposed) {
-            if (namedNamespace.members.has(n) || namedNamespace.forbiddenNameds.has(n)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    assign = (named, namedNamespace, name) => {
-        (0, Support_1.assert)(!this.names.has(named), `Name "${name}" assigned twice`);
-        (0, Support_1.assert)(!this.isConflicting(namedNamespace, name), `Assigned name "${name}" conflicts`);
-        this._names.set(named, name);
-        let namedsForName = this._namedsForName.get(name);
-        if (namedsForName === undefined) {
-            namedsForName = new Set();
-            this._namedsForName.set(name, namedsForName);
-        }
-        namedsForName.add(named);
-    };
-}
-// Naming algorithm
-function assignNames(rootNamespaces) {
-    const ctx = new NamingContext(rootNamespaces);
-    // Assign all fixed names.
-    for (const ns of ctx.namespaces) {
-        for (const n of ns.members) {
-            if (!n.isFixed())
-                continue;
-            ctx.assign(n, ns, n.fixedName);
-        }
-    }
-    for (;;) {
-        // 1. Find a namespace whose forbiddens are all fully named, and which has
-        //    at least one unnamed Named that has all its dependencies satisfied.
-        //    If no such namespace exists we're either done, or there's an unallowed
-        //    cycle.
-        const unfinishedNamespaces = (0, collection_utils_1.setFilter)(ctx.namespaces, ns => ctx.areForbiddensFullyNamed(ns));
-        const readyNamespace = (0, collection_utils_1.iterableFind)(unfinishedNamespaces, ns => (0, collection_utils_1.iterableSome)(ns.members, ctx.isReadyToBeNamed));
-        if (readyNamespace === undefined) {
-            // FIXME: Check for cycles?
-            return ctx.names;
-        }
-        const allForbiddenNames = (0, collection_utils_1.setUnion)(readyNamespace.members, readyNamespace.forbiddenNameds);
-        let forbiddenNames = (0, collection_utils_1.setFilterMap)(allForbiddenNames, n => ctx.names.get(n));
-        // 2. From low order to high order, sort those names into sets where all
-        //    members of a set propose the same name and have the same naming
-        //    function.
-        for (;;) {
-            const allReadyNames = (0, collection_utils_1.setFilter)(readyNamespace.members, ctx.isReadyToBeNamed);
-            const minOrderName = (0, collection_utils_1.iterableMinBy)(allReadyNames, n => n.order);
-            if (minOrderName === undefined)
-                break;
-            const minOrder = minOrderName.order;
-            const readyNames = (0, collection_utils_1.setFilter)(allReadyNames, n => n.order === minOrder);
-            // It would be nice if we had tuples, then we wouldn't have to do this in
-            // two steps.
-            const byNamingFunction = (0, collection_utils_1.setGroupBy)(readyNames, n => n.namingFunction);
-            for (const [namer, namedsForNamingFunction] of byNamingFunction) {
-                const byProposed = (0, collection_utils_1.setGroupBy)(namedsForNamingFunction, n => n.namingFunction.nameStyle(n.firstProposedName(ctx.names)));
-                for (const [, nameds] of byProposed) {
-                    // 3. Use each set's naming function to name its members.
-                    const names = namer.assignNames(ctx.names, forbiddenNames, nameds);
-                    for (const [name, assigned] of names) {
-                        ctx.assign(name, readyNamespace, assigned);
-                    }
-                    (0, collection_utils_1.setUnionInto)(forbiddenNames, names.values());
-                }
-            }
-        }
-    }
-}
-exports.assignNames = assignNames;

package/dist/quicktype-core/Renderer.d.ts

@@ -1,50 +0,0 @@
-import { TypeGraph } from "./TypeGraph";
-import { Name, Namespace } from "./Naming";
-import { Source, Sourcelike } from "./Source";
-import { AnnotationData } from "./Annotation";
-import { TargetLanguage } from "./TargetLanguage";
-export type RenderResult = {
-    sources: ReadonlyMap<string, Source>;
-    names: ReadonlyMap<Name, string>;
-};
-export type BlankLinePosition = "none" | "interposing" | "leading" | "leading-and-interposing";
-export type BlankLineConfig = BlankLinePosition | [BlankLinePosition, number];
-export type RenderContext = {
-    typeGraph: TypeGraph;
-    leadingComments: string[] | undefined;
-};
-export type ForEachPosition = "first" | "last" | "middle" | "only";
-export declare abstract class Renderer {
-    protected readonly targetLanguage: TargetLanguage;
-    protected readonly typeGraph: TypeGraph;
-    protected readonly leadingComments: string[] | undefined;
-    private _names;
-    private _finishedFiles;
-    private _finishedEmitContexts;
-    private _emitContext;
-    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext);
-    ensureBlankLine(numBlankLines?: number): void;
-    preventBlankLine(): void;
-    emitItem(item: Sourcelike): void;
-    emitItemOnce(item: Sourcelike): boolean;
-    emitLineOnce(...lineParts: Sourcelike[]): void;
-    emitLine(...lineParts: Sourcelike[]): void;
-    emitMultiline(linesString: string): void;
-    gatherSource(emitter: () => void): Sourcelike[];
-    emitGatheredSource(items: Sourcelike[]): void;
-    emitAnnotated(annotation: AnnotationData, emitter: () => void): void;
-    emitIssue(message: string, emitter: () => void): void;
-    protected emitTable: (tableArray: Sourcelike[][]) => void;
-    changeIndent(offset: number): void;
-    iterableForEach<T>(iterable: Iterable<T>, emitter: (v: T, position: ForEachPosition) => void): void;
-    forEach<K, V>(iterable: Iterable<[K, V]>, interposedBlankLines: number, leadingBlankLines: number, emitter: (v: V, k: K, position: ForEachPosition) => void): boolean;
-    forEachWithBlankLines<K, V>(iterable: Iterable<[K, V]>, blankLineConfig: BlankLineConfig, emitter: (v: V, k: K, position: ForEachPosition) => void): boolean;
-    indent(fn: () => void): void;
-    protected abstract setUpNaming(): Iterable<Namespace>;
-    protected abstract emitSource(givenOutputFilename: string): void;
-    private assignNames;
-    protected initializeEmitContextForFilename(filename: string): void;
-    protected finishFile(filename: string): void;
-    render(givenOutputFilename: string): RenderResult;
-    get names(): ReadonlyMap<Name, string>;
-}

package/dist/quicktype-core/Renderer.js

@@ -1,274 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Renderer = void 0;
-const collection_utils_1 = require("collection-utils");
-const Naming_1 = require("./Naming");
-const Source_1 = require("./Source");
-const Annotation_1 = require("./Annotation");
-const Support_1 = require("./support/Support");
-function getBlankLineConfig(cfg) {
-    if (Array.isArray(cfg)) {
-        return { position: cfg[0], count: cfg[1] };
-    }
-    return { position: cfg, count: 1 };
-}
-function lineIndentation(line) {
-    const len = line.length;
-    let indent = 0;
-    for (let i = 0; i < len; i++) {
-        const c = line.charAt(i);
-        if (c === " ") {
-            indent += 1;
-        }
-        else if (c === "\t") {
-            indent = (indent / 4 + 1) * 4;
-        }
-        else {
-            return { indent, text: line.substring(i) };
-        }
-    }
-    return { indent: 0, text: null };
-}
-class EmitContext {
-    _lastNewline;
-    // @ts-ignore: Initialized in startEmit, which is called from the constructor
-    _emitted;
-    // @ts-ignore: Initialized in startEmit, which is called from the constructor
-    _currentEmitTarget;
-    // @ts-ignore: Initialized in startEmit, which is called from the constructor
-    _numBlankLinesNeeded;
-    // @ts-ignore: Initialized in startEmit, which is called from the constructor
-    _preventBlankLine;
-    constructor() {
-        this._currentEmitTarget = this._emitted = [];
-        this._numBlankLinesNeeded = 0;
-        this._preventBlankLine = true; // no blank lines at start of file
-    }
-    get isEmpty() {
-        return this._emitted.length === 0;
-    }
-    get isNested() {
-        return this._emitted !== this._currentEmitTarget;
-    }
-    get source() {
-        return this._emitted;
-    }
-    pushItem(item) {
-        this._currentEmitTarget.push(item);
-        this._preventBlankLine = false;
-    }
-    emitNewline() {
-        const nl = (0, Source_1.newline)();
-        this.pushItem(nl);
-        this._lastNewline = nl;
-    }
-    emitItem(item) {
-        if (!this.isEmpty) {
-            for (let i = 0; i < this._numBlankLinesNeeded; i++) {
-                this.emitNewline();
-            }
-        }
-        this._numBlankLinesNeeded = 0;
-        this.pushItem(item);
-    }
-    containsItem(item) {
-        const existingItem = this._currentEmitTarget.find((value) => item === value);
-        return existingItem !== undefined;
-    }
-    ensureBlankLine(numBlankLines) {
-        if (this._preventBlankLine)
-            return;
-        this._numBlankLinesNeeded = Math.max(this._numBlankLinesNeeded, numBlankLines);
-    }
-    preventBlankLine() {
-        this._numBlankLinesNeeded = 0;
-        this._preventBlankLine = true;
-    }
-    changeIndent(offset) {
-        if (this._lastNewline === undefined) {
-            return (0, Support_1.panic)("Cannot change indent for the first line");
-        }
-        this._lastNewline.indentationChange += offset;
-    }
-}
-class Renderer {
-    targetLanguage;
-    typeGraph;
-    leadingComments;
-    _names;
-    _finishedFiles;
-    _finishedEmitContexts;
-    _emitContext;
-    constructor(targetLanguage, renderContext) {
-        this.targetLanguage = targetLanguage;
-        this.typeGraph = renderContext.typeGraph;
-        this.leadingComments = renderContext.leadingComments;
-        this._finishedFiles = new Map();
-        this._finishedEmitContexts = new Map();
-        this._emitContext = new EmitContext();
-    }
-    ensureBlankLine(numBlankLines = 1) {
-        this._emitContext.ensureBlankLine(numBlankLines);
-    }
-    preventBlankLine() {
-        this._emitContext.preventBlankLine();
-    }
-    emitItem(item) {
-        this._emitContext.emitItem(item);
-    }
-    emitItemOnce(item) {
-        if (this._emitContext.containsItem(item)) {
-            return false;
-        }
-        this.emitItem(item);
-        return true;
-    }
-    emitLineOnce(...lineParts) {
-        let lineEmitted = true;
-        if (lineParts.length === 1) {
-            lineEmitted = this.emitItemOnce(lineParts[0]);
-        }
-        else if (lineParts.length > 1) {
-            lineEmitted = this.emitItemOnce(lineParts);
-        }
-        if (lineEmitted) {
-            this._emitContext.emitNewline();
-        }
-    }
-    emitLine(...lineParts) {
-        if (lineParts.length === 1) {
-            this._emitContext.emitItem(lineParts[0]);
-        }
-        else if (lineParts.length > 1) {
-            this._emitContext.emitItem(lineParts);
-        }
-        this._emitContext.emitNewline();
-    }
-    emitMultiline(linesString) {
-        const lines = linesString.split("\n");
-        const numLines = lines.length;
-        if (numLines === 0)
-            return;
-        this.emitLine(lines[0]);
-        let currentIndent = 0;
-        for (let i = 1; i < numLines; i++) {
-            const line = lines[i];
-            const { indent, text } = lineIndentation(line);
-            (0, Support_1.assert)(indent % 4 === 0, "Indentation is not a multiple of 4.");
-            if (text !== null) {
-                const newIndent = indent / 4;
-                this.changeIndent(newIndent - currentIndent);
-                currentIndent = newIndent;
-                this.emitLine(text);
-            }
-            else {
-                this._emitContext.emitNewline();
-            }
-        }
-        if (currentIndent !== 0) {
-            this.changeIndent(-currentIndent);
-        }
-    }
-    gatherSource(emitter) {
-        const oldEmitContext = this._emitContext;
-        this._emitContext = new EmitContext();
-        emitter();
-        (0, Support_1.assert)(!this._emitContext.isNested, "emit context not restored correctly");
-        const source = this._emitContext.source;
-        this._emitContext = oldEmitContext;
-        return source;
-    }
-    emitGatheredSource(items) {
-        for (const item of items) {
-            this._emitContext.emitItem(item);
-        }
-    }
-    emitAnnotated(annotation, emitter) {
-        const lines = this.gatherSource(emitter);
-        const source = (0, Source_1.sourcelikeToSource)(lines);
-        this._emitContext.emitItem((0, Source_1.annotated)(annotation, source));
-    }
-    emitIssue(message, emitter) {
-        this.emitAnnotated(new Annotation_1.IssueAnnotationData(message), emitter);
-    }
-    emitTable = (tableArray) => {
-        if (tableArray.length === 0)
-            return;
-        const table = tableArray.map(r => r.map(sl => (0, Source_1.sourcelikeToSource)(sl)));
-        this._emitContext.emitItem({ kind: "table", table });
-        this._emitContext.emitNewline();
-    };
-    changeIndent(offset) {
-        this._emitContext.changeIndent(offset);
-    }
-    iterableForEach(iterable, emitter) {
-        const items = Array.from(iterable);
-        let onFirst = true;
-        for (const [i, v] of (0, collection_utils_1.iterableEnumerate)(items)) {
-            const position = items.length === 1 ? "only" : onFirst ? "first" : i === items.length - 1 ? "last" : "middle";
-            emitter(v, position);
-            onFirst = false;
-        }
-    }
-    forEach(iterable, interposedBlankLines, leadingBlankLines, emitter) {
-        let didEmit = false;
-        this.iterableForEach(iterable, ([k, v], position) => {
-            if (position === "only" || position === "first") {
-                this.ensureBlankLine(leadingBlankLines);
-            }
-            else {
-                this.ensureBlankLine(interposedBlankLines);
-            }
-            emitter(v, k, position);
-            didEmit = true;
-        });
-        return didEmit;
-    }
-    forEachWithBlankLines(iterable, blankLineConfig, emitter) {
-        const { position, count } = getBlankLineConfig(blankLineConfig);
-        const interposing = ["interposing", "leading-and-interposing"].indexOf(position) >= 0;
-        const leading = ["leading", "leading-and-interposing"].indexOf(position) >= 0;
-        return this.forEach(iterable, interposing ? count : 0, leading ? count : 0, emitter);
-    }
-    indent(fn) {
-        this.changeIndent(1);
-        fn();
-        this.changeIndent(-1);
-    }
-    assignNames() {
-        return (0, Naming_1.assignNames)(this.setUpNaming());
-    }
-    initializeEmitContextForFilename(filename) {
-        if (this._finishedEmitContexts.has(filename.toLowerCase())) {
-            const existingEmitContext = this._finishedEmitContexts.get(filename.toLowerCase());
-            if (existingEmitContext !== undefined) {
-                this._emitContext = existingEmitContext;
-            }
-        }
-    }
-    finishFile(filename) {
-        if (this._finishedFiles.has(filename)) {
-            console.log(`[WARNING] Tried to emit file ${filename} more than once. If performing multi-file output this warning can be safely ignored.`);
-        }
-        const source = (0, Source_1.sourcelikeToSource)(this._emitContext.source);
-        this._finishedFiles.set(filename, source);
-        // [Michael Fey (@MrRooni), 2019-5-9] We save the current EmitContext for possible reuse later. We put it into the map with a lowercased version of the key so we can do a case-insensitive lookup later. The reason we lowercase it is because some schema (looking at you keyword-unions.schema) define objects of the same name with different casing. BOOL vs. bool, for example.
-        this._finishedEmitContexts.set(filename.toLowerCase(), this._emitContext);
-        this._emitContext = new EmitContext();
-    }
-    render(givenOutputFilename) {
-        this._names = this.assignNames();
-        this.emitSource(givenOutputFilename);
-        if (!this._emitContext.isEmpty) {
-            this.finishFile(givenOutputFilename);
-        }
-        return { sources: this._finishedFiles, names: this._names };
-    }
-    get names() {
-        if (this._names === undefined) {
-            return (0, Support_1.panic)("Names accessed before they were assigned");
-        }
-        return this._names;
-    }
-}
-exports.Renderer = Renderer;