@loongdotjs/electron-winstaller 5.4.0

package/src/index.ts

@@ -0,0 +1,271 @@
+import * as asar from '@electron/asar';
+import { createTempDir } from './temp-utils';
+import * as fs from 'fs-extra';
+import { Metadata, SquirrelWindowsOptions, PersonMetadata } from './options';
+import * as path from 'path';
+import * as os from 'os';
+import { exec } from 'child_process';
+import spawn from './spawn-promise';
+import { template } from 'lodash';
+import { createSignTool, resetSignTool } from './sign';
+
+export { SquirrelWindowsOptions } from './options';
+export { SquirrelWindowsOptions as Options} from './options';
+
+const log = require('debug')('electron-windows-installer:main');
+
+/**
+ * A utility function to convert SemVer version strings into NuGet-compatible
+ * version strings.
+ * @param version A SemVer version string
+ * @returns A NuGet-compatible version string
+ * @see {@link https://semver.org/ | Semantic Versioning specification}
+ * @see {@link https://learn.microsoft.com/en-us/nuget/concepts/package-versioning?tabs=semver20sort | NuGet versioning specification}
+ */
+export function convertVersion(version: string): string {
+  const parts = version.split('+')[0].split('-');
+  const mainVersion = parts.shift();
+
+  if (parts.length > 0) {
+    return [mainVersion, parts.join('-').replace(/\./g, '')].join('-');
+  } else {
+    return mainVersion as string;
+  }
+}
+
+function checkIfCommandExists(command: string): Promise<boolean> {
+  const checkCommand = os.platform() === 'win32' ? 'where' : 'which';
+  return new Promise((resolve) => {
+    exec(`${checkCommand} ${command}`, (error) => {
+      resolve(error ? false : true);
+    });
+  });
+}
+
+/**
+ * This package's main function, which creates a Squirrel.Windows executable
+ * installer and optionally code-signs the output.
+ *
+ * @param options Options for installer generation and signing
+ * @see {@link https://github.com/Squirrel/Squirrel.Windows | Squirrel.Windows}
+ */
+export async function createWindowsInstaller(options: SquirrelWindowsOptions): Promise<void> {
+  let useMono = false;
+
+  const monoExe = 'mono';
+  const wineExe = ['arm64', 'x64'].includes(process.arch) ? 'wine64' : 'wine';
+
+  if (process.platform !== 'win32') {
+    useMono = true;
+    const [hasWine, hasMono] = await Promise.all([
+      checkIfCommandExists(wineExe),
+      checkIfCommandExists(monoExe)
+    ]);
+
+    if (!hasWine || !hasMono) {
+      throw new Error('You must install both Mono and Wine on non-Windows');
+    }
+
+    log(`Using Mono: '${monoExe}'`);
+    log(`Using Wine: '${wineExe}'`);
+  }
+
+  // eslint-disable-next-line prefer-const
+  let { appDirectory, outputDirectory, loadingGif } = options;
+  outputDirectory = path.resolve(outputDirectory || 'installer');
+
+  const vendorPath = options.vendorDirectory || path.join(__dirname, '..', 'vendor');
+  const vendorUpdate = path.join(vendorPath, 'Squirrel.exe');
+  const appUpdate = path.join(appDirectory, 'Squirrel.exe');
+
+  await fs.copy(vendorUpdate, appUpdate);
+  if (options.setupIcon && (options.skipUpdateIcon !== true)) {
+    let cmd = path.join(vendorPath, 'rcedit.exe');
+    const args = [
+      appUpdate,
+      '--set-icon', options.setupIcon
+    ];
+
+    if (useMono) {
+      args.unshift(cmd);
+      cmd = wineExe;
+    }
+
+    await spawn(cmd, args);
+  }
+
+  const defaultLoadingGif = path.join(__dirname, '..', 'resources', 'install-spinner.gif');
+  loadingGif = loadingGif ? path.resolve(loadingGif) : defaultLoadingGif;
+
+  const { certificateFile, certificatePassword, remoteReleases, signWithParams, remoteToken, windowsSign } = options;
+
+  const metadata: Metadata = {
+    description: '',
+    iconUrl: 'https://raw.githubusercontent.com/electron/electron/main/shell/browser/resources/win/electron.ico'
+  };
+
+  if (options.usePackageJson !== false) {
+    const appResources = path.join(appDirectory, 'resources');
+    const asarFile = path.join(appResources, 'app.asar');
+    let appMetadata;
+
+    if (await fs.pathExists(asarFile)) {
+      appMetadata = JSON.parse(asar.extractFile(asarFile, 'package.json').toString());
+    } else {
+      appMetadata = await fs.readJson(path.join(appResources, 'app', 'package.json'));
+    }
+
+    Object.assign(metadata, {
+      exe: `${appMetadata.name}.exe`,
+      title: appMetadata.productName || appMetadata.name
+    }, appMetadata);
+  }
+
+  Object.assign(metadata, options);
+
+  if (!metadata.authors) {
+    if (typeof (metadata.author) === 'string') {
+      metadata.authors = metadata.author;
+    } else {
+      metadata.authors = (metadata.author || ({} as PersonMetadata)).name || '';
+    }
+  }
+
+  metadata.owners = metadata.owners || metadata.authors;
+  metadata.version = convertVersion(metadata.version as string);
+  metadata.copyright = metadata.copyright ||
+    `Copyright © ${new Date().getFullYear()} ${metadata.authors || metadata.owners}`;
+  metadata.additionalFiles = metadata.additionalFiles || [];
+
+  if (await fs.pathExists(path.join(appDirectory, 'swiftshader'))) {
+    metadata.additionalFiles.push({ src: 'swiftshader\\**', target: 'lib\\net45\\swiftshader' });
+  }
+
+  if (await fs.pathExists(path.join(appDirectory, 'vk_swiftshader_icd.json'))) {
+    metadata.additionalFiles.push({ src: 'vk_swiftshader_icd.json', target: 'lib\\net45' });
+  }
+
+  const templatePath = options.nuspecTemplate || path.join(__dirname, '..', 'template.nuspectemplate');
+  let templateData = await fs.readFile(templatePath, 'utf8');
+  if (path.sep === '/') {
+    templateData = templateData.replace(/\\/g, '/');
+    for (const f of metadata.additionalFiles) {
+      f.src = f.src.replace(/\\/g, '/');
+      f.target = f.target.replace(/\\/g, '/');
+    }
+  }
+  const nuspecContent = template(templateData)(metadata);
+
+  log(`Created NuSpec file:\n${nuspecContent}`);
+
+  const nugetOutput = await createTempDir('si-');
+  const targetNuspecPath = path.join(nugetOutput, metadata.name + '.nuspec');
+
+  await fs.writeFile(targetNuspecPath, nuspecContent);
+
+  let cmd = path.join(vendorPath, 'nuget.exe');
+  let args = [
+    'pack', targetNuspecPath,
+    '-BasePath', appDirectory,
+    '-OutputDirectory', nugetOutput,
+    '-NoDefaultExcludes'
+  ];
+
+  if (useMono) {
+    args.unshift(cmd);
+    cmd = monoExe;
+  }
+
+  // Call NuGet to create our package
+  log(await spawn(cmd, args));
+  const nupkgPath = path.join(nugetOutput, `${metadata.name}.${metadata.version}.nupkg`);
+
+  if (remoteReleases) {
+    cmd = path.join(vendorPath, 'SyncReleases.exe');
+    args = ['-u', remoteReleases, '-r', outputDirectory];
+
+    if (useMono) {
+      args.unshift(cmd);
+      cmd = monoExe;
+    }
+
+    if (remoteToken) {
+      args.push('-t', remoteToken);
+    }
+
+    log(await spawn(cmd, args));
+  }
+
+  cmd = path.join(vendorPath, 'Squirrel.exe');
+  args = [
+    '--releasify', nupkgPath,
+    '--releaseDir', outputDirectory,
+    '--loadingGif', loadingGif
+  ];
+
+  if (useMono) {
+    args.unshift(path.join(vendorPath, 'Squirrel-Mono.exe'));
+    cmd = monoExe;
+  }
+
+  // Legacy codesign options
+  await resetSignTool();
+  if (signWithParams) {
+    args.push('--signWithParams');
+    if (!signWithParams.includes('/f') && !signWithParams.includes('/p') && certificateFile && certificatePassword) {
+      args.push(`${signWithParams} /a /f "${path.resolve(certificateFile)}" /p "${certificatePassword}"`);
+    } else {
+      args.push(signWithParams);
+    }
+  } else if (certificateFile && certificatePassword) {
+    args.push('--signWithParams');
+    args.push(`/a /f "${path.resolve(certificateFile)}" /p "${certificatePassword}"`);
+  // @electron/windows-sign options
+  } else if (windowsSign) {
+    args.push('--signWithParams');
+    args.push('windows-sign');
+    await createSignTool(options);
+  }
+
+  if (options.setupIcon) {
+    args.push('--setupIcon');
+    args.push(path.resolve(options.setupIcon));
+  }
+
+  if (options.noMsi) {
+    args.push('--no-msi');
+  }
+
+  if (options.noDelta) {
+    args.push('--no-delta');
+  }
+
+  if (options.frameworkVersion) {
+    args.push('--framework-version');
+    args.push(options.frameworkVersion);
+  }
+
+  log(await spawn(cmd, args));
+
+  if (options.fixUpPaths !== false) {
+    log('Fixing up paths');
+
+    if (metadata.productName || options.setupExe) {
+      const setupPath = path.join(outputDirectory, options.setupExe || `${metadata.productName}Setup.exe`);
+      const unfixedSetupPath = path.join(outputDirectory, 'Setup.exe');
+      log(`Renaming ${unfixedSetupPath} => ${setupPath}`);
+      await fs.rename(unfixedSetupPath, setupPath);
+    }
+
+    if (metadata.productName || options.setupMsi) {
+      const msiPath = path.join(outputDirectory, options.setupMsi || `${metadata.productName}Setup.msi`);
+      const unfixedMsiPath = path.join(outputDirectory, 'Setup.msi');
+      if (await fs.pathExists(unfixedMsiPath)) {
+        log(`Renaming ${unfixedMsiPath} => ${msiPath}`);
+        await fs.rename(unfixedMsiPath, msiPath);
+      }
+    }
+  }
+
+  await resetSignTool();
+}

package/src/options.ts

@@ -0,0 +1,228 @@
+// Originally from @types/electron-winstaller@2.6.2
+// Original definitions by: Brendan Forster <https://github.com/shiftkey>, Daniel Perez Alvarez <https://github.com/unindented>
+// Original definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { SignToolOptions } from '@electron/windows-sign';
+
+export interface SquirrelWindowsOptions {
+  /**
+   * The folder path of your Electron app
+   */
+  appDirectory: string;
+  /**
+   * The folder path of Squirrel windows
+   */
+  vendorDirectory?: string;
+  /**
+   * The folder path to create the .exe installer in.
+   *
+   * @defaultValue an `installer` folder at the project root.
+   */
+  outputDirectory?: string;
+  /**
+   * The path to the .nuspectemplate file used by Squirrel.exe.
+   *
+   * @defaultValue the bundled {@link https://github.com/electron/windows-installer/blob/main/template.nuspectemplate | template.nuspectemplate}.
+   */
+  nuspecTemplate?: string;
+  /**
+   * The local path to a `.gif` file to display during install.
+   *
+   * @defaultValue the bundled {@link https://github.com/electron/windows-installer/blob/main/resources/install-spinner.gif | install-spinner.gif}
+   */
+  loadingGif?: string;
+  /**
+   * The `authors` value for the NuGet package metadata.
+   *
+   * @defaultValue the `author` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  authors?: string;
+  /**
+   * The `owners` value for the NuGet package metadata.
+   *
+   * @defaultValue the `authors` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  owners?: string;
+  /**
+   * The `copyright` value for the NuGet package metadata.
+   *
+   * @defaultValue a generated copyright with {@link SquirrelWindowsOptions.authors | authors}
+   * or {@link SquirrelWindowsOptions.owners | owners}.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  copyright?: string;
+  /**
+   * The name of your app's main `.exe` file.
+   *
+   * @defaultValue the `name` field in your app's package.json file with an added `.exe` extension
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   */
+  exe?: string;
+  /**
+   * The `description` value for the NuGet package metadata.
+   *
+   * @defaultValue the `description` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  description?: string;
+  /**
+   * The `version` value for the Nuget package metadata.
+   *
+   * @defaultValue the `version` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  version?: string;
+  /**
+   * The `title` value for the nuget package metadata.
+   *
+   * @defaultValue the `productName` field and then the `name` field from your app's package.json
+   * file unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/nuget/reference/nuspec | the Microsoft .nuspec reference}.
+   */
+  title?: string;
+  /**
+   * Windows Application Model ID (appId).
+   *
+   * @defaultValue the `name` field in your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   * @see {@link https://learn.microsoft.com/en-us/windows/win32/shell/appids | Microsoft's Application User Model IDs documentation}.
+   */
+  name?: string;
+  /**
+   * The path to an Authenticode Code Signing Certificate.
+   *
+   * This is a legacy parameter provided for backwards compatibility.
+   * For more comprehensive support of various codesigning scenarios
+   * like EV certificates, see the
+   * {@link SquirrelWindowsOptions.windowsSign | windowsSign} parameter.
+   */
+  certificateFile?: string;
+  /**
+   * The password to decrypt the certificate given in `certificateFile`
+   *
+   * This is a legacy parameter provided for backwards compatibility.
+   * For more comprehensive support of various codesigning scenarios
+   * like EV certificates, see the
+   * {@link SquirrelWindowsOptions.windowsSign | windowsSign} parameter.
+   */
+  certificatePassword?: string;
+  /**
+   * Params to pass to signtool.
+   *
+   * Overrides {@link SquirrelWindowsOptions.certificateFile | certificateFile}
+   * and {@link SquirrelWindowsOptions.certificatePassword | certificatePassword}`.
+   *
+   * This is a legacy parameter provided for backwards compatibility.
+   * For more comprehensive support of various codesigning scenarios
+   * like EV certificates, see the
+   * {@link SquirrelWindowsOptions.windowsSign | windowsSign} parameter.
+   */
+  signWithParams?: string;
+  /**
+   * A publicly accessible, fully qualified HTTP(S) URL to an ICO file, used as the application icon
+   * displayed in Control Panel ➡ Programs and Features. The icon is retrieved at install time.
+   * Example: http://example.com/favicon.ico
+   *
+   * Does not accept `file:` URLs.
+   *
+   * @defaultValue the Electron icon.
+   */
+  iconUrl?: string;
+  /**
+   * The ICO file to use as the icon for the generated Setup.exe
+   */
+  setupIcon?: string;
+  /**
+   * The name to use for the generated Setup.exe file
+   * @defaultValue the `productName` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   */
+  setupExe?: string;
+  /**
+   * The name to use for the generated Setup.msi file
+   * @defaultValue the `productName` field from your app's package.json file
+   * unless {@link SquirrelWindowsOptions.usePackageJson | usePackageJson} is false.
+   */
+  setupMsi?: string;
+  /**
+   * Enable this flag to prevent Squirrel.Windows from creating an MSI installer.
+   * @defaultValue false
+   */
+  noMsi?: boolean;
+  /**
+   * Enable this flag to prevent Squirrel.Windows from creating delta packages (disable only if necessary, they are a Good Thing).
+   * @defaultValue false
+   */
+  noDelta?: boolean;
+  /**
+   * A URL to your existing updates. If given, these will be downloaded to create delta updates.
+   */
+  remoteReleases?: string;
+  /**
+   * Authentication token for remote updates using {@link SquirrelWindowsOptions.remoteReleases | remoteReleases}
+   */
+  remoteToken?: string;
+  /**
+   * Whether or not to infer metadata options from your app's package.json file.
+   * @defaultValue true
+   */
+  usePackageJson?: boolean;
+  /**
+   * Set the required .NET framework version (e.g. `net461`).
+   */
+  frameworkVersion?: string;
+  /**
+   * Attempt to create more descriptive installer names using metadata parameters.
+   * @defaultValue false
+   */
+  fixUpPaths?: boolean;
+  /**
+   * Enable this flag to skip setting a custom icon for `Update.exe`
+   * @defaultValue false
+   */
+  skipUpdateIcon?: boolean;
+
+  /**
+   * Requires Node.js 18 or newer.
+   *
+   * Sign your app with `@electron/windows-sign`, allowing for full customization
+   * of the code-signing process - and supports more complicated scenarios like
+   * cloud-hosted EV certificates, custom sign pipelines, and per-file overrides.
+   * It also supports all existing "simple" codesigning scenarios, including
+   * just passing a certificate file and password.
+   *
+   * @see {@link https://github.com/electron/windows-sign | @electron/windows-sign documentation}
+   * for all possible configuration options.
+   */
+  windowsSign?: SignToolOptions;
+}
+
+export interface PersonMetadata {
+  name: string;
+  email?: string;
+  url?: string;
+}
+
+export interface AdditionalFile {
+  src: string;
+  target: string;
+}
+
+export interface Metadata {
+  name?: string;
+  productName?: string;
+  version?: string;
+  copyright?: string;
+  author?: string | PersonMetadata;
+  authors?: string | PersonMetadata[];
+  owners?: string | PersonMetadata[];
+  description?: string;
+  iconUrl?: string;
+  additionalFiles?: AdditionalFile[];
+}

package/src/sign.ts

@@ -0,0 +1,89 @@
+import type { createSeaSignTool as createSeaSignToolType } from '@electron/windows-sign';
+import path from 'path';
+import semver from 'semver';
+import fs from 'fs-extra';
+
+import { SquirrelWindowsOptions } from './options';
+
+let VENDOR_PATH: string;
+let ORIGINAL_SIGN_TOOL_PATH: string;
+let BACKUP_SIGN_TOOL_PATH: string;
+let SIGN_LOG_PATH: string;
+
+/**
+ * This method uses @electron/windows-sign to create a fake signtool.exe
+ * that can be called by Squirrel - but then just calls @electron/windows-sign
+ * to actually perform the signing.
+ *
+ * That's useful for users who need a high degree of customization of the signing
+ * process but still want to use @electron/windows-installer.
+ */
+export async function createSignTool(options: SquirrelWindowsOptions): Promise<void> {
+  if (!options.windowsSign) {
+    throw new Error('Signtool should only be created if windowsSign options are set');
+  }
+
+  VENDOR_PATH = options.vendorDirectory || path.join(__dirname, '..', 'vendor');
+  ORIGINAL_SIGN_TOOL_PATH = path.join(VENDOR_PATH, 'signtool.exe');
+  BACKUP_SIGN_TOOL_PATH = path.join(VENDOR_PATH, 'signtool-original.exe');
+  SIGN_LOG_PATH = path.join(VENDOR_PATH, 'electron-windows-sign.log');
+
+  const createSeaSignTool = await getCreateSeaSignTool();
+
+  await resetSignTool();
+  await fs.remove(SIGN_LOG_PATH);
+
+  // Make a backup of signtool.exe
+  await fs.copy(ORIGINAL_SIGN_TOOL_PATH, BACKUP_SIGN_TOOL_PATH, { overwrite: true });
+
+  // Create a new signtool.exe using @electron/windows-sign
+  await createSeaSignTool({
+    path: ORIGINAL_SIGN_TOOL_PATH,
+    windowsSign: options.windowsSign
+  });
+}
+
+/**
+ * Ensure that signtool.exe is actually the "real" signtool.exe, not our
+ * fake substitute.
+ */
+export async function resetSignTool() {
+  if (fs.existsSync(BACKUP_SIGN_TOOL_PATH)) {
+    // Reset the backup of signtool.exe
+    await fs.copy(BACKUP_SIGN_TOOL_PATH, ORIGINAL_SIGN_TOOL_PATH, { overwrite: true });
+    await fs.remove(BACKUP_SIGN_TOOL_PATH);
+  }
+}
+
+/**
+ * @electron/windows-installer only requires Node.js >= 8.0.0.
+ * @electron/windows-sign requires Node.js >= 16.0.0.
+ * @electron/windows-sign's "fake signtool.exe" feature requires
+ * Node.js >= 20.0.0, the first version to contain the "single
+ * executable" feature with proper support.
+ *
+ * Since this is overall a very niche feature and only benefits
+ * consumers with rather advanced codesigning needs, we did not
+ * want to make Node.js v18 a hard requirement for @electron/windows-installer.
+ *
+ * Instead, @electron/windows-sign is an optional dependency - and
+ * if it didn't install, we'll throw a useful error here.
+ *
+ * @returns
+ */
+async function getCreateSeaSignTool(): Promise<typeof createSeaSignToolType> {
+  try {
+    const { createSeaSignTool } = await import('@electron/windows-sign');
+    return createSeaSignTool;
+  } catch(error) {
+    let message  = 'In order to use windowsSign options, @electron/windows-sign must be installed as a dependency.';
+
+    if (semver.lte(process.version, '20.0.0')) {
+      message += ` You are currently using Node.js ${process.version}. Please upgrade to Node.js 19 or later and reinstall all dependencies to ensure that @electron/windows-sign is available.`;
+    } else {
+      message += ` ${error}`;
+    }
+
+    throw new Error(message);
+  }
+}

package/src/spawn-promise.ts

@@ -0,0 +1,55 @@
+import { spawn as spawnOg, SpawnOptionsWithoutStdio } from 'child_process';
+
+const d = require('debug')('electron-windows-installer:spawn');
+
+// Public: Maps a process's output into an {Observable}
+//
+// exe - The program to execute
+// params - Arguments passed to the process
+// opts - Options that will be passed to child_process.spawn
+//
+// Returns an {Observable} with a single value, that is the output of the
+// spawned process
+export default function spawn(exe: string, params: string[], opts?: SpawnOptionsWithoutStdio): Promise<string> {
+  return new Promise((resolve, reject): void => {
+    let proc = null;
+
+    d(`Spawning ${exe} ${params.join(' ')}`);
+    if (!opts) {
+      proc = spawnOg(exe, params);
+    } else {
+      proc = spawnOg(exe, params, opts);
+    }
+
+    // We need to wait until all three events have happened:
+    // * stdout's pipe is closed
+    // * stderr's pipe is closed
+    // * We've got an exit code
+    let rejected = false;
+    let refCount = 3;
+    let stdout = '';
+
+    const release = (): void => {
+      if (--refCount <= 0 && !rejected) resolve(stdout);
+    };
+
+    const bufHandler = (chunk: string): void => {
+      stdout += chunk;
+    };
+
+    proc.stdout.setEncoding('utf8').on('data', bufHandler);
+    proc.stdout.once('close', release);
+    proc.stderr.setEncoding('utf8').on('data', bufHandler);
+    proc.stderr.once('close', release);
+    proc.on('error', (e: Error): void => reject(e));
+
+    proc.on('close', (code: number): void => {
+      if (code === 0) {
+        release();
+      } else {
+        rejected = true;
+        reject(new Error(`Failed with exit code: ${code}\nOutput:\n${stdout}`));
+      }
+    });
+  });
+}

package/src/temp-utils.ts

@@ -0,0 +1,9 @@
+import * as temp from 'temp';
+import { promisify } from 'util';
+temp.track();
+
+const createTempDir = promisify(temp.mkdir);
+
+export {
+  createTempDir
+};

package/template.nuspectemplate

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id><%- name %></id>
+    <title><%- title %></title>
+    <version><%- version %></version>
+    <authors><%- authors %></authors>
+    <owners><%- owners %></owners>
+    <iconUrl><%- iconUrl %></iconUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description><%- description %></description>
+    <copyright><%- copyright %></copyright>
+  </metadata>
+  <files>
+    <file src="locales\**" target="lib\net45\locales" />
+    <file src="resources\**" target="lib\net45\resources" />
+    <file src="*.bin" target="lib\net45" />
+    <file src="*.dll" target="lib\net45" />
+    <file src="*.pak" target="lib\net45" />
+    <file src="*.exe.config" target="lib\net45" />
+    <file src="*.exe.sig" target="lib\net45" />
+    <file src="icudtl.dat" target="lib\net45\icudtl.dat" />
+    <file src="Squirrel.exe" target="lib\net45\squirrel.exe" />
+    <file src="LICENSE" target="lib\net45\LICENSE" />
+    <file src="<%- exe %>" target="lib\net45\<%- exe %>" />
+    <% additionalFiles.forEach(function(f) { %>
+    <file src="<%- f.src %>" target="<%- f.target %>" />
+    <% }); %>
+  </files>
+</package>