jsii-pacmak 1.64.0 → 1.65.0

package/bin/jsii-pacmak.js

@@ -36,6 +36,15 @@ const version_1 = require("../lib/version");
         type: 'boolean',
         desc: 'generate code only (instead of building and packaging)',
         default: false,
+    })
+        .option('runtime-type-checking', {
+        type: 'boolean',
+        desc: [
+            'generate runtime type checking code where compile-time type checking is not possible.',
+            'Disabling this will generate less code, but will produce less helpful error messages when',
+            'developers pass invalid values to the generated bindings.',
+        ].join(' '),
+        default: true,
     })
         .option('fingerprint', {
         type: 'boolean',
@@ -154,6 +163,7 @@ const version_1 = require("../lib/version");
         recurse: argv.recurse,
         rosettaUnknownSnippets,
         rosettaTablet: argv['rosetta-tablet'],
+        runtimeTypeChecking: argv['runtime-type-checking'],
         targets: argv.targets?.map((target) => target),
         updateNpmIgnoreFiles: argv.npmignore,
         validateAssemblies: argv['validate-assemblies'],

package/lib/builder.d.ts

@@ -8,34 +8,39 @@ export interface BuildOptions {
      * Whether to fingerprint the produced artifacts.
      * @default true
      */
-    fingerprint?: boolean;
+    readonly fingerprint?: boolean;
     /**
      * Whether artifacts should be re-build even if their fingerprints look up-to-date.
      * @default false
      */
-    force?: boolean;
+    readonly force?: boolean;
     /**
      * Arguments provided by the user (how they are used is target-dependent)
      */
-    arguments: {
+    readonly arguments: {
         readonly [name: string]: any;
     };
     /**
      * Only generate code, don't build
      */
-    codeOnly?: boolean;
+    readonly codeOnly?: boolean;
     /**
      * Whether or not to clean
      */
-    clean?: boolean;
+    readonly clean?: boolean;
     /**
      * Whether to add an additional subdirectory for the target language
      */
-    languageSubdirectory?: boolean;
+    readonly languageSubdirectory?: boolean;
     /**
      * The Rosetta instance to load examples from
      */
-    rosetta: Rosetta;
+    readonly rosetta: Rosetta;
+    /**
+     * Whether to generate runtime type checking code in places where compile-time
+     * type checking is not possible.
+     */
+    readonly runtimeTypeChecking: boolean;
 }
 /**
  * Interface for classes that can build language targets

package/lib/builder.js

@@ -63,13 +63,14 @@ class IndependentPackageBuilder {
     }
     makeTarget(module, options) {
         return new this.targetConstructor({
-            targetName: this.targetName,
-            packageDir: module.moduleDirectory,
+            arguments: options.arguments,
             assembly: module.assembly,
             fingerprint: options.fingerprint,
             force: options.force,
-            arguments: options.arguments,
+            packageDir: module.moduleDirectory,
             rosetta: options.rosetta,
+            runtimeTypeChecking: options.runtimeTypeChecking,
+            targetName: this.targetName,
         });
     }
     finalOutputDir(module, options) {

package/lib/generator.d.ts

@@ -20,6 +20,11 @@ export interface GeneratorOptions {
      * If this property is set, the generator will add "Base" to abstract class names
      */
     addBasePostfixToAbstractClassNames?: boolean;
+    /**
+     * If this property is set, the generator will add runtime type checking code in places
+     * where compile-time type checking is not possible.
+     */
+    runtimeTypeChecking: boolean;
 }
 export interface IGenerator {
     /**
@@ -72,7 +77,8 @@ export declare abstract class Generator implements IGenerator {
     private _assembly?;
     protected _reflectAssembly?: reflect.Assembly;
     private fingerprint?;
-    constructor(options?: GeneratorOptions);
+    constructor(options: GeneratorOptions);
+    protected get runtimeTypeChecking(): boolean;
     protected get assembly(): spec.Assembly;
     get reflectAssembly(): reflect.Assembly;
     get metadata(): {

package/lib/generator.js

@@ -13,11 +13,14 @@ const version_1 = require("./version");
  * Given a jsii module, it will invoke "events" to emit various elements.
  */
 class Generator {
-    constructor(options = {}) {
+    constructor(options) {
         this.options = options;
         this.excludeTypes = new Array();
         this.code = new codemaker_1.CodeMaker();
     }
+    get runtimeTypeChecking() {
+        return this.options.runtimeTypeChecking;
+    }
     get assembly() {
         if (!this._assembly) {
             throw new Error('No assembly has been loaded! The #load() method must be called first!');

package/lib/index.d.ts

@@ -6,7 +6,7 @@ export { configure as configureLogging } from './logging';
 /**
  * Generates code in the desired targets.
  */
-export declare function pacmak({ argv, clean, codeOnly, fingerprint, force, forceSubdirectory, forceTarget, inputDirectories, outputDirectory, parallel, recurse, rosettaTablet, targets, timers, rosettaUnknownSnippets, updateNpmIgnoreFiles, validateAssemblies, }: PacmakOptions): Promise<void>;
+export declare function pacmak({ argv, clean, codeOnly, fingerprint, force, forceSubdirectory, forceTarget, inputDirectories, outputDirectory, parallel, recurse, rosettaTablet, rosettaUnknownSnippets, runtimeTypeChecking, targets, timers, updateNpmIgnoreFiles, validateAssemblies, }: PacmakOptions): Promise<void>;
 /**
  * Options provided to the `pacmak` function.
  */
@@ -93,6 +93,12 @@ export interface PacmakOptions {
      * @default undefined
      */
     readonly rosettaTablet?: string;
+    /**
+     * Whether to inject runtime type checks in places where compile-time type checking is not performed.
+     *
+     * @default true
+     */
+    readonly runtimeTypeChecking?: boolean;
     /**
      * The list of targets for which code should be generated. Unless `forceTarget` is `true`, a given target will only
      * be generated for assemblies that have configured it.

package/lib/index.js

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "configureLogging", { enumerable: true, get: func
 /**
  * Generates code in the desired targets.
  */
-async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint = true, force = false, forceSubdirectory = true, forceTarget = false, inputDirectories, outputDirectory, parallel = true, recurse = false, rosettaTablet, targets = Object.values(targets_1.TargetName), timers = new timer_1.Timers(), rosettaUnknownSnippets = undefined, updateNpmIgnoreFiles = false, validateAssemblies = false, }) {
+async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint = true, force = false, forceSubdirectory = true, forceTarget = false, inputDirectories, outputDirectory, parallel = true, recurse = false, rosettaTablet, rosettaUnknownSnippets = undefined, runtimeTypeChecking = true, targets = Object.values(targets_1.TargetName), timers = new timer_1.Timers(), updateNpmIgnoreFiles = false, validateAssemblies = false, }) {
     const rosetta = new jsii_rosetta_1.Rosetta({
         unknownSnippets: rosettaUnknownSnippets,
         prefixDisclaimer: true,
@@ -74,6 +74,7 @@ async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint =
                 force,
                 perLanguageDirectory,
                 rosetta,
+                runtimeTypeChecking,
             }))
                 .then(() => logging.info(`${targetSet.targetType} finished`), (err) => {
                 logging.warn(`${targetSet.targetType} failed`);
@@ -95,20 +96,21 @@ async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint =
 exports.pacmak = pacmak;
 //#endregion
 //#region Building
-async function buildTargetsForLanguage(targetLanguage, modules, { argv, clean, codeOnly, fingerprint, force, perLanguageDirectory, rosetta, }) {
+async function buildTargetsForLanguage(targetLanguage, modules, { argv, clean, codeOnly, fingerprint, force, perLanguageDirectory, rosetta, runtimeTypeChecking, }) {
     // ``argv.target`` is guaranteed valid by ``yargs`` through the ``choices`` directive.
     const factory = targets_1.ALL_BUILDERS[targetLanguage];
     if (!factory) {
         throw new Error(`Unsupported target: '${targetLanguage}'`);
     }
     return factory(modules, {
+        arguments: argv,
         clean: clean,
         codeOnly: codeOnly,
-        rosetta,
-        force: force,
         fingerprint: fingerprint,
-        arguments: argv,
+        force: force,
         languageSubdirectory: perLanguageDirectory,
+        rosetta,
+        runtimeTypeChecking,
     }).buildModules();
 }
 function sliceTargets(modulesSorted, requestedTargets, force) {

package/lib/target.d.ts

@@ -12,6 +12,7 @@ export declare abstract class Target {
     protected readonly targetName: string;
     protected readonly assembly: reflect.Assembly;
     protected readonly rosetta: Rosetta;
+    protected readonly runtimeTypeChecking: boolean;
     protected abstract readonly generator: IGenerator;
     constructor(options: TargetOptions);
     /**
@@ -125,6 +126,8 @@ export interface TargetOptions {
     assembly: reflect.Assembly;
     /** The Rosetta instance */
     rosetta: Rosetta;
+    /** Whether to generate runtime type-checking code */
+    runtimeTypeChecking: boolean;
     /**
      * Whether to fingerprint the produced artifacts.
      * @default true

package/lib/target.js

@@ -8,12 +8,13 @@ const dependency_graph_1 = require("./dependency-graph");
 const logging = require("./logging");
 class Target {
     constructor(options) {
-        this.packageDir = options.packageDir;
+        this.arguments = options.arguments;
         this.assembly = options.assembly;
-        this.rosetta = options.rosetta;
         this.fingerprint = options.fingerprint ?? true;
         this.force = options.force ?? false;
-        this.arguments = options.arguments;
+        this.packageDir = options.packageDir;
+        this.rosetta = options.rosetta;
+        this.runtimeTypeChecking = options.runtimeTypeChecking;
         this.targetName = options.targetName;
     }
     /**

package/lib/targets/dotnet/dotnetgenerator.d.ts

@@ -7,13 +7,16 @@ import { Generator, Legalese } from '../../generator';
  */
 export declare class DotNetGenerator extends Generator {
     private readonly assembliesCurrentlyBeingCompiled;
+    private readonly nameutils;
     private readonly rosetta;
     private firstMemberWritten;
     private typeresolver;
-    private readonly nameutils;
     private dotnetRuntimeGenerator;
     private dotnetDocGenerator;
-    constructor(assembliesCurrentlyBeingCompiled: string[], rosetta: Rosetta);
+    constructor(assembliesCurrentlyBeingCompiled: string[], options: {
+        readonly rosetta: Rosetta;
+        readonly runtimeTypeChecking: boolean;
+    });
     load(packageRoot: string, assembly: reflect.Assembly): Promise<void>;
     /**
      * Runs the generator (in-memory).

package/lib/targets/dotnet/dotnetgenerator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DotNetGenerator = void 0;
 const spec = require("@jsii/spec");
 const clone = require("clone");
+const crypto_1 = require("crypto");
 const fs = require("fs-extra");
 const http = require("http");
 const https = require("https");
@@ -18,18 +19,18 @@ const nameutils_1 = require("./nameutils");
  * CODE GENERATOR V2
  */
 class DotNetGenerator extends generator_1.Generator {
-    constructor(assembliesCurrentlyBeingCompiled, rosetta) {
-        super();
+    constructor(assembliesCurrentlyBeingCompiled, options) {
+        super(options);
         this.assembliesCurrentlyBeingCompiled = assembliesCurrentlyBeingCompiled;
-        this.rosetta = rosetta;
+        this.nameutils = new nameutils_1.DotNetNameUtils();
         // Flags that tracks if we have already wrote the first member of the class
         this.firstMemberWritten = false;
-        this.nameutils = new nameutils_1.DotNetNameUtils();
         // Override the openBlock to get a correct C# looking code block with the curly brace after the line
         this.code.openBlock = function (text) {
             this.line(text);
             this.open('{');
         };
+        this.rosetta = options.rosetta;
     }
     async load(packageRoot, assembly) {
         await super.load(packageRoot, assembly);
@@ -443,6 +444,10 @@ class DotNetGenerator extends generator_1.Generator {
      * @param noMangle   use parameter names as-is (useful for setters, for example) instead of mangling them.
      */
     emitUnionParameterValdation(parameters, { noMangle = false } = {}) {
+        if (!this.runtimeTypeChecking) {
+            // We were configured not to emit those, so bail out now.
+            return;
+        }
         const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
         if (unionParameters == null || unionParameters.length === 0) {
             return;
@@ -479,13 +484,19 @@ class DotNetGenerator extends generator_1.Generator {
             }
         }
         function validateArray(value, descr, elementType, parameterName) {
-            const varName = `__idx_${descr.replace(/[^a-z0-9_]/gi, '_')}`;
+            const varName = `__idx_${(0, crypto_1.createHash)('sha256')
+                .update(descr)
+                .digest('hex')
+                .slice(0, 6)}`;
             this.code.openBlock(`for (int ${varName} = 0 ; ${varName} < ${value}.Length ; ${varName}++)`);
             validate.call(this, `${value}[${varName}]`, `${descr}[{${varName}}]`, elementType, parameterName);
             this.code.closeBlock();
         }
         function validateMap(value, descr, elementType, parameterName) {
-            const varName = `__item_${descr.replace(/[^a-z0-9_]/gi, '_')}`;
+            const varName = `__item_${(0, crypto_1.createHash)('sha256')
+                .update(descr)
+                .digest('hex')
+                .slice(0, 6)}`;
             this.code.openBlock(`foreach (var ${varName} in ${value})`);
             validate.call(this, `${varName}.Value`, `${descr}[\\"{${varName}.Key}\\"]`, elementType, parameterName);
             this.code.closeBlock();
@@ -518,6 +529,13 @@ class DotNetGenerator extends generator_1.Generator {
                 this.code.line(`${prefix}!(${test})`);
                 emitAnd = true;
             }
+            if (typeRefs.some((ref) => spec.isNamedTypeReference(ref) &&
+                spec.isInterfaceType(this.findType(ref.fqn)))) {
+                // AnonymousObject will convert to any interface type, even if unsafely. It is the opaque
+                // type returned when a non-intrinsically typed value is passed through an any or union
+                // return point. We basically cannot type-check that at runtime in a complete way.
+                this.code.line(`&& !(${value} is Amazon.JSII.Runtime.Deputy.AnonymousObject)`);
+            }
             this.code.unindent(')');
             this.code.openBlock('');
             const placeholders = typeRefs

package/lib/targets/dotnet.js

@@ -164,13 +164,14 @@ class DotnetBuilder {
     }
     makeTarget(module) {
         return new Dotnet({
-            targetName: this.targetName,
-            packageDir: module.moduleDirectory,
+            arguments: this.options.arguments,
             assembly: module.assembly,
             fingerprint: this.options.fingerprint,
             force: this.options.force,
-            arguments: this.options.arguments,
+            packageDir: module.moduleDirectory,
             rosetta: this.options.rosetta,
+            runtimeTypeChecking: this.options.runtimeTypeChecking,
+            targetName: this.targetName,
         }, this.modules.map((m) => m.name));
     }
 }
@@ -185,7 +186,7 @@ function projectLocation(module) {
 class Dotnet extends target_1.Target {
     constructor(options, assembliesCurrentlyBeingCompiled) {
         super(options);
-        this.generator = new dotnetgenerator_1.DotNetGenerator(assembliesCurrentlyBeingCompiled, options.rosetta);
+        this.generator = new dotnetgenerator_1.DotNetGenerator(assembliesCurrentlyBeingCompiled, options);
     }
     static toPackageInfos(assm) {
         const packageId = assm.targets.dotnet.packageId;

package/lib/targets/java.d.ts

@@ -47,7 +47,6 @@ export default class Java extends Target {
     build(sourceDir: string, outDir: string): Promise<void>;
 }
 declare class JavaGenerator extends Generator {
-    private readonly rosetta;
     private static readonly RESERVED_KEYWORDS;
     /**
      * Turns a raw javascript property name (eg: 'default') into a safe Java property name (eg: 'defaultValue').
@@ -69,7 +68,11 @@ declare class JavaGenerator extends Generator {
      * interface proxies.
      */
     private readonly referencedModules;
-    constructor(rosetta: Rosetta);
+    private readonly rosetta;
+    constructor(options: {
+        readonly rosetta: Rosetta;
+        readonly runtimeTypeChecking: boolean;
+    });
     protected onBeginAssembly(assm: spec.Assembly, fingerprint: boolean): void;
     protected onEndAssembly(assm: spec.Assembly, fingerprint: boolean): void;
     protected getAssemblyOutputDir(mod: spec.Assembly): string;

package/lib/targets/java.js

@@ -225,13 +225,14 @@ class JavaBuilder {
     }
     makeTarget(module, options) {
         return new Java({
-            targetName: this.targetName,
-            packageDir: module.moduleDirectory,
+            arguments: options.arguments,
             assembly: module.assembly,
             fingerprint: options.fingerprint,
             force: options.force,
-            arguments: options.arguments,
+            packageDir: module.moduleDirectory,
             rosetta: options.rosetta,
+            runtimeTypeChecking: options.runtimeTypeChecking,
+            targetName: this.targetName,
         });
     }
 }
@@ -247,7 +248,7 @@ function moduleArtifactsSubdir(module) {
 class Java extends target_1.Target {
     constructor(options) {
         super(options);
-        this.generator = new JavaGenerator(options.rosetta);
+        this.generator = new JavaGenerator(options);
     }
     static toPackageInfos(assm) {
         const groupId = assm.targets.java.maven.groupId;
@@ -329,9 +330,8 @@ const MODULE_CLASS_NAME = '$Module';
 const INTERFACE_PROXY_CLASS_NAME = 'Jsii$Proxy';
 const INTERFACE_DEFAULT_CLASS_NAME = 'Jsii$Default';
 class JavaGenerator extends generator_1.Generator {
-    constructor(rosetta) {
-        super({ generateOverloadsForMethodWithOptionals: true });
-        this.rosetta = rosetta;
+    constructor(options) {
+        super({ ...options, generateOverloadsForMethodWithOptionals: true });
         /**
          * A map of all the modules ever referenced during code generation. These include
          * direct dependencies but can potentially also include transitive dependencies, when,
@@ -339,6 +339,7 @@ class JavaGenerator extends generator_1.Generator {
          * interface proxies.
          */
         this.referencedModules = {};
+        this.rosetta = options.rosetta;
     }
     /**
      * Turns a raw javascript property name (eg: 'default') into a safe Java property name (eg: 'defaultValue').

package/lib/targets/js.d.ts

@@ -13,6 +13,7 @@ export default class JavaScript extends Target {
     build(sourceDir: string, outDir: string): Promise<void>;
 }
 declare class PackOnly extends Generator {
+    constructor();
     save(outdir: string, tarball: string, _: Legalese): Promise<string[]>;
     protected getAssemblyOutputDir(_mod: spec.Assembly): string;
     protected onBeginInterface(_ifc: spec.InterfaceType): void;

package/lib/targets/js.js

@@ -55,6 +55,10 @@ exports.default = JavaScript;
 // # CODE GENERATOR #
 // ##################
 class PackOnly extends generator_1.Generator {
+    constructor() {
+        // NB: This does not generate code, so runtime type checking is irrelevant
+        super({ runtimeTypeChecking: false });
+    }
     async save(outdir, tarball, _) {
         // Intentionally ignore the Legalese field here... it's not useful here.
         return super.save(outdir, tarball, {});

package/lib/targets/python/type-name.js

@@ -214,7 +214,7 @@ class UserType {
         const submodulePythonName = toPythonFqn(submodule, assembly).pythonFqn;
         const typeSubmodulePythonName = toPythonFqn(findParentSubmodule(assembly.types[__classPrivateFieldGet(this, _UserType_fqn, "f")], assembly), assembly).pythonFqn;
         if (typeSubmodulePythonName === submodulePythonName) {
-            // Identifiy declarations that are not yet initialized and hence cannot be
+            // Identify declarations that are not yet initialized and hence cannot be
             // used as part of a type qualification. Since this is not a forward
             // reference, the type was already emitted and its un-qualified name must
             // be used instead of it's locally qualified name.

package/lib/targets/python.d.ts

@@ -13,6 +13,8 @@ export default class Python extends Target {
 interface EmitContext extends NamingContext {
     /** @deprecated The TypeResolver */
     readonly resolver: TypeResolver;
+    /** Whether to emit runtime type checking code */
+    readonly runtimeTypeChecking: boolean;
 }
 interface PythonBase {
     readonly pythonName: string;
@@ -49,7 +51,7 @@ declare class PythonGenerator extends Generator {
     private package;
     private rootModule?;
     private readonly types;
-    constructor(rosetta: Rosetta, options?: GeneratorOptions);
+    constructor(rosetta: Rosetta, options: GeneratorOptions);
     emitDocString(code: CodeMaker, apiLocation: ApiLocation, docs: spec.Docs | undefined, options?: {
         arguments?: DocumentableArgument[];
         documentableItem?: string;

package/lib/targets/python.js

@@ -26,7 +26,7 @@ const DOCSTRING_QUOTES = "'''";
 class Python extends target_1.Target {
     constructor(options) {
         super(options);
-        this.generator = new PythonGenerator(options.rosetta);
+        this.generator = new PythonGenerator(options.rosetta, options);
     }
     async generateCode(outDir, tarball) {
         await super.generateCode(outDir, tarball);
@@ -440,7 +440,7 @@ class BaseMethod {
         });
         if ((this.shouldEmitBody || forceEmitBody) &&
             (!renderAbstract || !this.abstract)) {
-            emitParameterTypeChecks(code, pythonParams.slice(1), `${(0, type_name_1.toPythonFullName)(this.parent.fqn, context.assembly)}.${this.pythonName}`);
+            emitParameterTypeChecks(code, context, pythonParams.slice(1), `${(0, type_name_1.toPythonFullName)(this.parent.fqn, context.assembly)}.${this.pythonName}`);
         }
         this.emitBody(code, context, renderAbstract, forceEmitBody, liftedPropNames, pythonParams[0], returnType);
         code.closeBlock();
@@ -597,7 +597,7 @@ class BaseProperty {
             openSignature(code, 'def', this.pythonName, [this.implicitParameter, `value: ${pythonType}`], 'None');
             if ((this.shouldEmitBody || forceEmitBody) &&
                 (!renderAbstract || !this.abstract)) {
-                emitParameterTypeChecks(code, [`value: ${pythonType}`], 
+                emitParameterTypeChecks(code, context, [`value: ${pythonType}`], 
                 // In order to get a property accessor, we must resort to getting the
                 // attribute on the type, instead of the value (where the getter would
                 // be implicitly invoked for us...)
@@ -744,7 +744,7 @@ class Struct extends BasePythonClassType {
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();
         }
-        emitParameterTypeChecks(code, kwargs, `${(0, type_name_1.toPythonFullName)(this.spec.fqn, context.assembly)}.__init__`);
+        emitParameterTypeChecks(code, context, kwargs, `${(0, type_name_1.toPythonFullName)(this.spec.fqn, context.assembly)}.__init__`);
         // Required properties, those will always be put into the dict
         assignDictionary(code, `${implicitParameter}._values: typing.Dict[str, typing.Any]`, members
             .filter((m) => !m.optional)
@@ -1580,7 +1580,7 @@ class TypeResolver {
     }
 }
 class PythonGenerator extends generator_1.Generator {
-    constructor(rosetta, options = {}) {
+    constructor(rosetta, options) {
         super(options);
         this.rosetta = rosetta;
         this.code.openBlockFormatter = (s) => `${s}:`;
@@ -1728,6 +1728,7 @@ class PythonGenerator extends generator_1.Generator {
             assembly: assm,
             emittedTypes: new Set(),
             resolver,
+            runtimeTypeChecking: this.runtimeTypeChecking,
             submodule: assm.name,
             typeResolver: (fqn) => resolver.dereference(fqn),
         });
@@ -2012,7 +2013,10 @@ function openSignature(code, keyword, name, params, returnType, lineComment) {
  * @param params      the parameter signatures to be type-checked.
  * @param typedEntity the type-annotated entity.
  */
-function emitParameterTypeChecks(code, params, typedEntity) {
+function emitParameterTypeChecks(code, context, params, typedEntity) {
+    if (!context.runtimeTypeChecking) {
+        return;
+    }
     const paramInfo = params.map((param) => {
         const [name] = param.split(/\s*[:=#]\s*/, 1);
         if (name === '*') {

package/lib/targets/version-utils.js

@@ -72,7 +72,7 @@ exports.toPythonVersionRange = toPythonVersionRange;
  * @returns the version that should be serialized
  */
 function toReleaseVersion(assemblyVersion, target) {
-    const version = (0, semver_1.parse)(assemblyVersion, { includePrerelease: true });
+    const version = (0, semver_1.parse)(assemblyVersion);
     if (version == null) {
         throw new Error(`Unable to parse the provided assembly version: "${assemblyVersion}"`);
     }

package/lib/version.d.ts

@@ -1,5 +1,5 @@
 /** The short version number for this JSII compiler (e.g: `X.Y.Z`) */
-export declare const VERSION = "1.64.0";
+export declare const VERSION = "1.65.0";
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.64.0 (build 4c1eae8)";
+export declare const VERSION_DESC = "1.65.0 (build 7a02b7f)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,9 +1,9 @@
 "use strict";
-// Generated at 2022-08-12T17:08:11Z by generate.sh
+// Generated at 2022-08-18T14:34:45Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION_DESC = exports.VERSION = void 0;
 /** The short version number for this JSII compiler (e.g: `X.Y.Z`) */
-exports.VERSION = '1.64.0';
+exports.VERSION = '1.65.0';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.64.0 (build 4c1eae8)';
+exports.VERSION_DESC = '1.65.0 (build 7a02b7f)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "description": "A code generation framework for jsii backend languages",
   "license": "Apache-2.0",
   "author": {
@@ -37,31 +37,33 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.64.0",
-    "@jsii/spec": "^1.64.0",
+    "@jsii/check-node": "1.65.0",
+    "@jsii/spec": "^1.65.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.64.0",
+    "codemaker": "^1.65.0",
     "commonmark": "^0.30.0",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.64.0",
-    "jsii-rosetta": "^1.64.0",
+    "jsii-reflect": "^1.65.0",
+    "jsii-rosetta": "^1.65.0",
     "semver": "^7.3.7",
     "spdx-license-list": "^6.6.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.64.0",
-    "@jsii/java-runtime": "^1.64.0",
-    "@jsii/go-runtime": "^1.64.0",
-    "@scope/jsii-calc-lib": "^1.64.0",
+    "@jsii/dotnet-runtime": "^1.65.0",
+    "@jsii/java-runtime": "^1.65.0",
+    "@jsii/go-runtime": "^1.65.0",
+    "@scope/jsii-calc-lib": "^1.65.0",
     "@types/clone": "^2.1.1",
+    "@types/diff": "^5.0.2",
     "@types/commonmark": "^0.27.5",
     "@types/fs-extra": "^9.0.13",
     "@types/semver": "^7.3.10",
-    "jsii": "^1.64.0",
-    "jsii-build-tools": "^1.64.0",
+    "diff": "^5.1.0",
+    "jsii": "^1.65.0",
+    "jsii-build-tools": "^1.65.0",
     "jsii-calc": "^3.20.120",
     "pyright": "^1.1.266"
   },