node canvas
v2.11.2
Node-Canvas é uma implementação de tela apoiada pelo Cairo para Node.JS.
Dica
v3.0.0-rc2 já está disponível para teste no Linux (x64 glibc), macOS (x64) e Windows (x64)! É a primeira versão a usar o N-API e o pré-construção. Por favor, tente e informe -nos se você tiver algum problema.
npm install canvas@next$ npm install canvasPor padrão, os binários pré-criados serão baixados se você estiver em uma das seguintes plataformas:
Se você deseja construir a partir da fonte, use npm install --build-from-source e consulte a seção de compilação abaixo.
A versão mínima do Node.js necessária é 18.12.0 .
Se você não tiver um sistema operacional ou arquitetura de processador suportado ou usa --build-from-source , o módulo será compilado no seu sistema. Isso requer várias dependências, incluindo Cairo e Pango.
Para obter informações detalhadas sobre a instalação, consulte o wiki. As instruções de instalação de uma linha para os sistemas operacionais comuns estão abaixo. Observe que libgif/giflib, librsvg e libjpeg são opcionais e somente necessários se você precisar de suporte GIF, SVG e JPEG, respectivamente. Cairo v1.10.0 ou posterior é necessário.
| OS | Comando |
|---|---|
| macos | Usando homebrew:brew install pkg-config cairo pango libpng jpeg giflib librsvg pixman python-setuptools |
| Ubuntu | sudo apt-get install build-essential libcairo2-dev libpango1.0-dev libjpeg-dev libgif-dev librsvg2-dev |
| Fedora | sudo yum install gcc-c++ cairo-devel pango-devel libjpeg-turbo-devel giflib-devel |
| Solaris | pkgin install cairo pango pkg-config xproto renderproto kbproto xextproto |
| OpenBSD | doas pkg_add cairo pango png jpeg giflib |
| Windows | Veja o wiki |
| Outros | Veja o wiki |
Mac OS X V10.11+: Se você atualizou recentemente para o Mac OS X V10.11+ e está enfrentando problemas ao compilar, execute o seguinte comando: xcode-select --install . Leia mais sobre o problema no transbordamento da pilha. Se você tiver o Xcode 10.0 ou superior instalado, para construir a partir da fonte, precisará do NPM 6.4.1 ou superior.
const { createCanvas , loadImage } = require ( 'canvas' )
const canvas = createCanvas ( 200 , 200 )
const ctx = canvas . getContext ( '2d' )
// Write "Awesome!"
ctx . font = '30px Impact'
ctx . rotate ( 0.1 )
ctx . fillText ( 'Awesome!' , 50 , 100 )
// Draw line under text
var text = ctx . measureText ( 'Awesome!' )
ctx . strokeStyle = 'rgba(0,0,0,0.5)'
ctx . beginPath ( )
ctx . lineTo ( 50 , 102 )
ctx . lineTo ( 50 + text . width , 102 )
ctx . stroke ( )
// Draw cat with lime helmet
loadImage ( 'examples/images/lime-cat.jpg' ) . then ( ( image ) => {
ctx . drawImage ( image , 50 , 0 , 70 , 70 )
console . log ( '<img src="' + canvas . toDataURL ( ) + '" />' )
} ) Veja o Changelog para obter um guia para atualizar de 1.x para 2.x.
Para a versão 1.x documentação, consulte o ramo v1.x.
Este projeto é uma implementação da API da Web Canvas e implementa essa API o mais próximo possível. Para documentação da API, visite a API da Mozilla Web Canvas. (Consulte o status de compatibilidade para a conformidade da API atual.) Todos os métodos de utilidade e APIs não padrão estão documentados abaixo.
createCanvas ( width : number , height : number , type ?: 'PDF' | 'SVG' ) = > Canvas
Cria uma instância de tela. Este método funciona no Node.js e nos navegadores da Web, onde não há construtor de tela. (Consulte browser.js para a implementação que é executada em navegadores.)
const { createCanvas } = require ( 'canvas' )
const mycanvas = createCanvas ( 200 , 200 )
const myPDFcanvas = createCanvas ( 600 , 800 , 'pdf' ) // see "PDF Support" sectioncreateImageData ( width : number , height : number ) = > ImageData createImageData ( data : Uint8ClampedArray , width : number , height ?: number ) = > ImageData // for alternative pixel formats: createImageData ( data : Uint16Array , width : number , height ?: number ) = > ImageData
Cria uma instância de imagem. Este método funciona em node.js e navegadores da web.
const { createImageData } = require ( 'canvas' )
const width = 20 , height = 20
const arraySize = width * height * 4
const mydata = createImageData ( new Uint8ClampedArray ( arraySize ) , width )loadImage ( ) = > Promise < Image >
Método de conveniência para carregar imagens. Este método funciona em node.js e navegadores da web.
const { loadImage } = require ( 'canvas' )
const myimg = loadImage ( 'http://server.com/image.png' )
myimg . then ( ( ) => {
// do something with image
} ) . catch ( err => {
console . log ( 'oh no!' , err )
} )
// or with async/await:
const myimg = await loadImage ( 'http://server.com/image.png' )
// do something with imageregisterFont ( path : string , { family : string , weight ?: string , style ?: string } ) = > void
Para usar um arquivo de fonte que não está instalado como uma fonte do sistema, use registerFont() para registrar a fonte no Canvas. Isso deve ser feito antes que a tela seja criada.
const { registerFont , createCanvas } = require ( 'canvas' )
registerFont ( 'comicsans.ttf' , { family : 'Comic Sans' } )
const canvas = createCanvas ( 500 , 500 )
const ctx = canvas . getContext ( '2d' )
ctx . font = '12px "Comic Sans"'
ctx . fillText ( 'Everyone hates this font :(' , 250 , 10 ) O segundo argumento é um objeto com propriedades que se assemelham às propriedades CSS especificadas nas regras @font-face . Você deve especificar pelo menos family . weight e style são opcionais e padrão ao 'normal' .
deregisterAllFonts ( ) = > void
Use deregisterAllFonts para não registrar todas as fontes que foram registradas anteriormente. Este método é útil quando você deseja remover todas as fontes registradas, como ao usar a tela em testes
const { registerFont , createCanvas , deregisterAllFonts } = require ( 'canvas' )
describe ( 'text rendering' , ( ) => {
afterEach ( ( ) => {
deregisterAllFonts ( ) ;
} )
it ( 'should render text with Comic Sans' , ( ) => {
registerFont ( 'comicsans.ttf' , { family : 'Comic Sans' } )
const canvas = createCanvas ( 500 , 500 )
const ctx = canvas . getContext ( '2d' )
ctx . font = '12px "Comic Sans"'
ctx . fillText ( 'Everyone loves this font :)' , 250 , 10 )
// assertScreenshot()
} )
} )img . src : string | Buffer
Como nos navegadores, img.src pode ser definido como um data: URI ou um URL remoto. Além disso, o Node-CANVAS permite definir src em um caminho de arquivo local ou instância Buffer .
const { Image } = require ( 'canvas' )
// From a buffer:
fs . readFile ( 'images/squid.png' , ( err , squid ) => {
if ( err ) throw err
const img = new Image ( )
img . onload = ( ) => ctx . drawImage ( img , 0 , 0 )
img . onerror = err => { throw err }
img . src = squid
} )
// From a local file path:
const img = new Image ( )
img . onload = ( ) => ctx . drawImage ( img , 0 , 0 )
img . onerror = err => { throw err }
img . src = 'images/squid.png'
// From a remote URL:
img . src = 'http://picsum.photos/200/300'
// ... as above
// From a `data:` URI:
img . src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=='
// ... as above Nota: Em alguns casos, img.src= é atualmente síncrono. No entanto, você deve sempre usar img.onload e img.onerror , pois pretendemos fazer img.src= sempre assíncrono como é nos navegadores. Veja #1007.
img . dataMode : number
Aplica -se a imagens JPEG atraídas apenas para telas em PDF.
Configuração img.dataMode = Image.MODE_MIME ou Image.MODE_MIME|Image.MODE_IMAGE Ativa o rastreamento de dados MIME de imagens. Quando os dados MIME são rastreados, as telas em PDF podem incorporar JPEGs diretamente na saída, em vez de re-codificar no PNG. Isso pode reduzir drasticamente o tamanho do arquivo e acelerar a renderização.
const { Image , createCanvas } = require ( 'canvas' )
const canvas = createCanvas ( w , h , 'pdf' )
const img = new Image ( )
img . dataMode = Image . MODE_IMAGE // Only image data tracked
img . dataMode = Image . MODE_MIME // Only mime data tracked
img . dataMode = Image . MODE_MIME | Image . MODE_IMAGE // Both are trackedSe estiver trabalhando com uma tela não PDF, os dados da imagem devem ser rastreados; caso contrário, a saída será lixo.
A ativação do rastreamento de dados MIME não tem benefícios (apenas uma desaceleração), a menos que você esteja gerando um PDF.
canvas . toBuffer ( ( err : Error | null , result : Buffer ) => void , mimeType ?: string , config ?: any ) = > void canvas . toBuffer ( mimeType ?: string , config ?: any ) = > Buffer
Cria um objeto Buffer representando a imagem contida na tela.
raw ou para telas PDF ou SVG.image/png , image/jpeg (se o node-canvas foi construído com suporte a jpeg), raw (dados não codificados em ordem BGRA em sistemas Little-Endian (a maioria), argb em sistemas big-endianos; de cima para baixo ), application/pdf (para telas em PDF) e image/svg+xml (para telas SVG). Padrões de image/png para telas de imagem ou o tipo correspondente para tela PDF ou SVG. Para image/jpeg , um objeto que especifica a qualidade (0 a 1), se a compactação progressiva deve ser usada e/ou se a subamostragem do croma deve ser usada: {quality: 0.75, progressive: false, chromaSubsampling: true} . Todas as propriedades são opcionais.
Para image/png , um objeto que especifica o nível de compressão do ZLIB (entre 0 e 9), o (s) filtro (s) de compressão, a paleta (somente PNGS indexado), o índice da paleta de fundo (somente PNGS indexado) e/ou a resolução ( ppi): {compressionLevel: 6, filters: canvas.PNG_ALL_FILTERS, palette: undefined, backgroundIndex: 0, resolution: undefined} . Todas as propriedades são opcionais.
Observe que o formato PNG codifica a resolução em pixels por metro; portanto, se você especificar 96 , o arquivo codificará 3780 ppm (~ 96,01 ppi). A resolução é indefinida por padrão para corresponder ao comportamento comum do navegador.
Para application/pdf , um objeto que especifica os metadados do documento opcional: {title: string, author: string, subject: string, keywords: string, creator: string, creationDate: Date, modDate: Date} . Todas as propriedades são opcionais e padrão para undefined , exceto o creationDate , que padroniza a data atual. A adição de metadados requer o Cairo 1.16.0 ou posterior.
Para uma descrição dessas propriedades, consulte a página 550 do PDF 32000-1: 2008.
Observe que não há separador padrão para keywords . Um espaço é recomendado porque é de uso comum por outros aplicativos, e o Cairo incluirá a lista de palavras -chave nas cotações se uma vírgula ou semicolon for usada.
Valor de retorno
Se nenhum retorno de chamada for fornecido, um Buffer . Se um retorno de chamada for fornecido, nenhum.
// Default: buf contains a PNG-encoded image
const buf = canvas . toBuffer ( )
// PNG-encoded, zlib compression level 3 for faster compression but bigger files, no filtering
const buf2 = canvas . toBuffer ( 'image/png' , { compressionLevel : 3 , filters : canvas . PNG_FILTER_NONE } )
// JPEG-encoded, 50% quality
const buf3 = canvas . toBuffer ( 'image/jpeg' , { quality : 0.5 } )
// Asynchronous PNG
canvas . toBuffer ( ( err , buf ) => {
if ( err ) throw err // encoding failed
// buf is PNG-encoded image
} )
canvas . toBuffer ( ( err , buf ) => {
if ( err ) throw err // encoding failed
// buf is JPEG-encoded image at 95% quality
} , 'image/jpeg' , { quality : 0.95 } )
// BGRA pixel values, native-endian
const buf4 = canvas . toBuffer ( 'raw' )
const { stride , width } = canvas
// In memory, this is `canvas.height * canvas.stride` bytes long.
// The top row of pixels, in BGRA order on little-endian hardware,
// left-to-right, is:
const topPixelsBGRALeftToRight = buf4 . slice ( 0 , width * 4 )
// And the third row is:
const row3 = buf4 . slice ( 2 * stride , 2 * stride + width * 4 )
// SVG and PDF canvases
const myCanvas = createCanvas ( w , h , 'pdf' )
myCanvas . toBuffer ( ) // returns a buffer containing a PDF-encoded canvas
// With optional metadata:
myCanvas . toBuffer ( 'application/pdf' , {
title : 'my picture' ,
keywords : 'node.js demo cairo' ,
creationDate : new Date ( )
} )canvas . createPNGStream ( config ?: any ) = > ReadableStream
Cria uma ReadableStream que emite dados codificados por PNG.
config um objeto especificando o nível de compressão ZLIB (entre 0 e 9), o (s) filtro (s) de compressão, a paleta (somente PNGS indexada) e/ou o índice de paleta de fundo (somente PNGs indexado): {compressionLevel: 6, filters: canvas.PNG_ALL_FILTERS, palette: undefined, backgroundIndex: 0, resolution: undefined} . Todas as propriedades são opcionais. const fs = require ( 'fs' )
const out = fs . createWriteStream ( __dirname + '/test.png' )
const stream = canvas . createPNGStream ( )
stream . pipe ( out )
out . on ( 'finish' , ( ) => console . log ( 'The PNG file was created.' ) ) Para codificar PNGs indexados de telas com pixelFormat: 'A8' ou 'A1' , forneça um objeto de opções:
const palette = new Uint8ClampedArray ( [
//r g b a
0 , 50 , 50 , 255 , // index 1
10 , 90 , 90 , 255 , // index 2
127 , 127 , 255 , 255
// ...
] )
canvas . createPNGStream ( {
palette : palette ,
backgroundIndex : 0 // optional, defaults to 0
} )canvas . createJPEGStream ( config ?: any ) = > ReadableStream
Cria uma ReadableStream que emite dados codificados por JPEG.
NOTA: No momento, createJPEGStream() é síncrono sob o capô. Ou seja, ele é executado no fio principal, não no Libuv Threadpool.
config um objeto especificando a qualidade (0 a 1), se a compactação progressiva deve ser usada e/ou se a subamostragem de Chroma deve ser usada: {quality: 0.75, progressive: false, chromaSubsampling: true} . Todas as propriedades são opcionais. const fs = require ( 'fs' )
const out = fs . createWriteStream ( __dirname + '/test.jpeg' )
const stream = canvas . createJPEGStream ( )
stream . pipe ( out )
out . on ( 'finish' , ( ) => console . log ( 'The JPEG file was created.' ) )
// Disable 2x2 chromaSubsampling for deeper colors and use a higher quality
const stream = canvas . createJPEGStream ( {
quality : 0.95 ,
chromaSubsampling : false
} )canvas . createPDFStream ( config ?: any ) = > ReadableStream
config um objeto que especifica metadados do documento opcional: {title: string, author: string, subject: string, keywords: string, creator: string, creationDate: Date, modDate: Date} . Consulte toBuffer() para obter mais informações. A adição de metadados requer o Cairo 1.16.0 ou posterior. Aplica -se apenas a telas em PDF. Cria uma ReadableStream que emite o PDF codificado. canvas.toBuffer() também produz um PDF codificado, mas createPDFStream() pode ser usado para reduzir o uso da memória.
Esta é uma API padrão, mas várias chamadas fora do padrão são suportadas. A lista completa de chamadas suportadas é:
dataUrl = canvas . toDataURL ( ) // defaults to PNG
dataUrl = canvas . toDataURL ( 'image/png' )
dataUrl = canvas . toDataURL ( 'image/jpeg' )
dataUrl = canvas . toDataURL ( 'image/jpeg' , quality ) // quality from 0 to 1
canvas . toDataURL ( ( err , png ) => { } ) // defaults to PNG
canvas . toDataURL ( 'image/png' , ( err , png ) => { } )
canvas . toDataURL ( 'image/jpeg' , ( err , jpeg ) => { } ) // sync JPEG is not supported
canvas . toDataURL ( 'image/jpeg' , { ... opts } , ( err , jpeg ) => { } ) // see Canvas#createJPEGStream for valid options
canvas . toDataURL ( 'image/jpeg' , quality , ( err , jpeg ) => { } ) // spec-following; quality from 0 to 1context . patternQuality : 'fast' | 'good' | 'best' | 'nearest' | 'bilinear'
Padrão para 'good' . Afeta o padrão (gradiente, imagem, etc.), renderizando a qualidade.
context . quality : 'fast' | 'good' | 'best' | 'nearest' | 'bilinear'
Padrão para 'good' . Como patternQuality , mas se aplica a transformações que afetam mais do que apenas padrões.
context . textDrawingMode : 'path' | 'glyph'
Padrões para 'path' . O efeito depende do tipo de tela:
glyph padrão (imagem) e path resultam em texto rasterizado. O modo de glifos é mais rápido que path , mas pode resultar em texto de menor qualidade, especialmente quando girado ou traduzido.
glyph PDF incorporará texto em vez de caminhos no PDF. Isso é mais rápido para codificar, mais rápido para abrir com os espectadores em PDF, produz um tamanho de arquivo menor e torna o texto selecionado. O subconjunto da fonte necessário para renderizar os glifos será incorporado no PDF. Geralmente é o modo que você deseja usar com telas em PDF.
glyph SVG não faz com que os elementos <text> sejam produzidos como se poderia esperar (Cairo Bug). Em vez disso, glyph criará uma seção <defs> com um <symbol> para cada glifo, então esses glifos serão reutilizados por meio de elementos <use> . O modo path cria um elemento <path> para cada sequência de texto. O modo glyph é mais rápido e produz um tamanho de arquivo menor.
No modo glyph , ctx.strokeText() e ctx.fillText() se comportam o mesmo (além de usar o estilo de acidente vascular cerebral e preenchimento, respectivamente).
Esta propriedade é rastreada como parte do estado de tela em salvar/restaurar.
Além de todas as operações compostas globais padrão definidas pela especificação Canvas, a operação 'saturada' também está disponível.
context . antialias : 'default' | 'none' | 'gray' | 'subpixel'
Define o modo anti-aliasing.
Node-Canvas pode criar documentos em PDF em vez de imagens. O tipo de tela deve ser definido ao criar a tela da seguinte forma:
const canvas = createCanvas ( 200 , 500 , 'pdf' ) Um método adicional .addPage() está disponível para criar várias páginas PDFs:
// On first page
ctx . font = '22px Helvetica'
ctx . fillText ( 'Hello World' , 50 , 80 )
ctx . addPage ( )
// Now on second page
ctx . font = '22px Helvetica'
ctx . fillText ( 'Hello World 2' , 50 , 80 )
canvas . toBuffer ( ) // returns a PDF file
canvas . createPDFStream ( ) // returns a ReadableStream that emits a PDF
// With optional document metadata (requires Cairo 1.16.0):
canvas . toBuffer ( 'application/pdf' , {
title : 'my picture' ,
keywords : 'node.js demo cairo' ,
creationDate : new Date ( )
} ) Também é possível criar páginas com tamanhos diferentes, passando width e height do método .addPage() :
ctx . font = '22px Helvetica'
ctx . fillText ( 'Hello World' , 50 , 80 )
ctx . addPage ( 400 , 800 )
ctx . fillText ( 'Hello World 2' , 50 , 80 )Veja também:
O Node-Canvas pode criar documentos SVG em vez de imagens. O tipo de tela deve ser definido ao criar a tela da seguinte forma:
const canvas = createCanvas ( 200 , 500 , 'svg' )
// Use the normal primitives.
fs . writeFileSync ( 'out.svg' , canvas . toBuffer ( ) ) Se o LIBRSVG estiver disponível quando o Node-Canvas for instalado, o Node-Canvas poderá renderizar imagens SVG ao seu contexto de tela. Atualmente, isso funciona rastejando a imagem SVG (ou seja, desenhando uma imagem SVG para uma tela SVG não preservará os dados SVG).
const img = new Image ( )
img . onload = ( ) => ctx . drawImage ( img , 0 , 0 )
img . onerror = err => { throw err }
img . src = './example.svg' O Node-Canvas possui suporte experimental para formatos adicionais de pixels, seguindo aproximadamente a proposta de espaço de cores da tela.
const canvas = createCanvas ( 200 , 200 )
const ctx = canvas . getContext ( '2d' , { pixelFormat : 'A8' } ) Por padrão, as telas são criadas no formato RGBA32 , que corresponde ao comportamento nativo da tela HTML. Cada pixel é de 32 bits. As APIs JavaScript que envolvem dados de pixel ( getImageData , putImageData ) armazenam as cores na ordem {Red, Green, Blue, alfa} sem pré-multiplicação alfa. (A API C ++ armazena as cores na ordem {alfa, vermelho, verde, azul} na ordem nativa-endiana, com pré-multiplicação alfa.)
Esses formatos de pixel adicionais têm suporte experimental:
RGB24 como RGBA32 , mas os 8 bits alfa são sempre opacos. Este formato é sempre usado se o atributo de contexto alpha for definido como false (ou seja, canvas.getContext('2d', {alpha: false}) ). Esse formato pode ser mais rápido que RGBA32 porque a transparência não precisa ser calculada.A8 Cada pixel é de 8 bits. Esse formato pode ser usado para criar imagens em escala de cinza (tratando cada byte como um valor alfa) ou para criar PNGs indexados (tratando cada byte como um índice de paleta) (consulte o exemplo usando valores alfa com fillStyle e o exemplo usando imageData ).RGB16_565 Cada pixel é de 16 bits, com vermelho nos 5 bits superiores, verde nos 6 bits do meio e azul nos 5 bits inferiores, na plataforma nativa Endianness. Alguns dispositivos de hardware e buffers de quadros usam este formato. Observe que o PNG não suporta esse formato; Ao criar um PNG, a imagem será convertida em RGB de 24 bits. Este formato é, portanto, abaixo do ideal para gerar PNGs. Instâncias ImageData para esse modo Use um Uint16Array em vez de um Uint8ClampedArray .A1 Cada pixel é de 1 bit e os pixels são embalados em quantidades de 32 bits. A ordem dos bits corresponde à Endianness da plataforma: em uma máquina pouco endiana, o primeiro pixel é o bit mais significativo. Este formato pode ser usado para criar imagens de cor única. O suporte a este formato está incompleto, veja a nota abaixo.RGB30 Cada pixel é de 30 bits, com vermelho nos 10 superiores, verde no meio 10 e azul nos 10.Notas e advertências:
O uso de um formato não padrão pode afetar o comportamento das APIs que envolvem dados de pixel:
context2d.createImageData O tamanho da matriz retornado depende do número de bits por pixel para o formato de dados de imagem subjacente, de acordo com as descrições acima.context2d.getImageData O formato da matriz retornado depende do modo de imagem subjacente, de acordo com as descrições acima. Esteja ciente da plataforma Endianness, que pode ser determinada usando a função os.endianness() do Node.js.context2d.putImageData como acima. A1 e RGB30 ainda não suportam getImageData ou putImageData . Tem um caso de uso e/ou opinião sobre como trabalhar com esses formatos? Abra um problema e informe -nos! (Veja #935.)
A1 , A8 , RGB30 e RGB16_565 com sombras Blurs podem travar ou não renderizar corretamente.
Os construtores ImageData(width, height) e ImageData(Uint8ClampedArray, width) assumem 4 bytes por pixel. Para criar uma instância ImageData com um número diferente de bytes por pixels, use new ImageData(new Uint8ClampedArray(size), width, height) ou new ImageData(new Uint16ClampedArray(size), width, height) .
Primeiro, verifique se você criou a versão mais recente. Obtenha todos os DEPS de que você precisa (consulte a compilação acima) e execute:
npm install --build-from-source
Para testes visuais: npm run test-server e aponte seu navegador para http: // localhost: 4000.
Para testes de unidade: npm run test .
Os benchmarks vivem no diretório benchmarks .
Exemplos alinham -se no diretório examples . A maioria produz uma imagem PNG com o mesmo nome, e outros como o Live Rock.js lançam um servidor HTTP a ser visualizado no navegador.
(A licença do MIT)
Copyright (c) 2010 LearnBoost e colaboradores <[email protected]>
Copyright (c) 2014 Automattic, Inc e colaboradores <[email protected]>
A permissão é concedida, gratuita, a qualquer pessoa que obtenha uma cópia deste software e arquivos de documentação associados (o 'software'), para lidar com o software sem restrição, inclusive sem limitação os direitos de uso, copiar, modificar, mesclar, mesclar .
O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todas as cópias ou em partes substanciais do software.
O software é fornecido 'como está', sem garantia de qualquer tipo, expresso ou implícito, incluindo, entre outros, as garantias de comercialização, aptidão para uma finalidade específica e não innoculação. Em nenhum caso os autores ou detentores de direitos autorais serão responsabilizados por qualquer reclamação, danos ou outro passivo, seja em uma ação de contrato, delito ou não, decorrente de, fora ou em conexão com o software ou o uso ou outras negociações nos Software.
Consulte a licença
