Barcode Generation

This commit is contained in:
CAnetzberger
2022-02-21 15:01:43 +01:00
parent aa6c93f3f6
commit 79ec11e25c
224 changed files with 22474 additions and 95 deletions

1
node_modules/jsbarcode/.dockerignore generated vendored Normal file
View File

@@ -0,0 +1 @@
**/node_modules

4
node_modules/jsbarcode/.eslintignore generated vendored Normal file
View File

@@ -0,0 +1,4 @@
test
bin
dist
example

24
node_modules/jsbarcode/.eslintrc generated vendored Normal file
View File

@@ -0,0 +1,24 @@
{
"env": {
"browser": true,
"node": true
},
"parserOptions": {
"ecmaVersion": 7,
"sourceType": "module",
"ecmaFeatures": {
"experimentalObjectRestSpread": true
}
},
"extends": "eslint:recommended",
"predef": "jQuery",
"rules": {
"curly": "error",
"semi": [1, "always"],
"no-console": 2,
"no-control-regex": 0,
"indent": [1, "tab", {"SwitchCase": 1}],
"space-infix-ops": ["error"],
"comma-spacing": ["error"]
}
}

16
node_modules/jsbarcode/.travis.yml generated vendored Normal file
View File

@@ -0,0 +1,16 @@
language: node_js
sudo: required
before_install:
- sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
- sudo apt-get update
- npm install -g gulp
install:
- sudo apt-get install libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev build-essential g++-4.8
- sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 50
- npm install
after_success: npm run coveralls
node_js:
- "node"
- "14"
- "12"
- "10"

84
node_modules/jsbarcode/CONTRIBUTING.md generated vendored Normal file
View File

@@ -0,0 +1,84 @@
Getting Started
----
We would :heart: to have pull requests for you. So here is how you start development with JsBarcode.
First fork and clone the repo:
````bash
git clone git@github.com:your-username/JsBarcode.git
````
Then run ``npm install`` to set everything up. Make sure you have all dependencies of [node-canvas](https://github.com/Automattic/node-canvas) installed before doing this, or check **Using Docker** section.
You are now ready to start doing your changes.
JsBarcode is using [gulp](http://gulpjs.com/) in the building step. Here comes some commands that will come handy when developing.
````bash
gulp compile # Compile the code (for nodejs)
gulp compile-web # Compiles down to JsBarcode.all.js
gulp compress # Compiles and compresses all individual barcode files
gulp watch # Listens to file changes and re-compiles automatically
gulp watch-web # Listens to file changes and re-compiles to JsBarcode.all.js automatically
gulp lint # Checking the code according to the code style specified in .eslintrc
````
Testing
----
JsBarcode has tests on all barcode symbologies (and more). If you want to test your changes just run ``npm test`` and the code will be compiled and tested.
There are also visual tests located under ``test/browser/``.
Using Docker
----
If you have installed [Docker](https://www.docker.com), you can avoid local installation of dependencies for [node-canvas](https://github.com/Automattic/node-canvas). For doing that, run ``npm install --ignore-scripts`` instead of ``npm install``. Then you can run tests by ``docker-compose up``
Symbologies and The Core
----
JsBarcode is divided up in two distinct parts. The barcode symbologies (EAN-13, CODE128, ITF, ...) and the core.
### Symbologies
Implementing a new symbology is the easiest way to contribute. Just follow the standard for that symbology and create a class that generate the correct binary data.
The structure of such a class is as follows:
````javascript
import Barcode from "../Barcode.js";
class GenericBarcode extends Barcode{
constructor(data, options){
super(data, options); // Sets this.data and this.text
}
// Return the corresponding binary numbers for the data provided
encode(){
return {
data: "10101010101010101010101010101010101010101",
text: this.text
};
}
// Resturn true/false if the string provided is valid for this encoder
valid(){
return true;
}
}
````
It might be a good idea to check one of the already implemented barcodes (such as [ITF14](https://github.com/lindell/JsBarcode/blob/master/src/barcodes/ITF14/index.js)) for inspiration.
### The Core / Renderers
The core part handles the API requests and calls the renderers. If you want to do any structural changes please [create an issue](https://github.com/lindell/JsBarcode/issues/new) or ask about it in the [gitter chat](https://gitter.im/lindell/JsBarcode) first.
Bug fixes is of course welcome at any time :+1:
Pull Requests
----
So you are ready to make a PR? Great! :smile:
But first make sure you have checked some things.
* Your code should follow the code style guide provided by [.eslintrc](https://github.com/lindell/JsBarcode/blob/master/.eslintrc) by running ``gulp lint``
* If you implemented a new symbology, make sure you have tests for it
* Don't commit build changes. No `dist/` or `bin/` changes in the PR.

13
node_modules/jsbarcode/Dockerfile generated vendored Normal file
View File

@@ -0,0 +1,13 @@
FROM node:8
RUN apt-get update && apt-get install -qq libcairo2-dev libjpeg-dev libpango1.0-dev libgif-dev build-essential g++
RUN mkdir -p /jsbarcode
WORKDIR /jsbarcode
COPY ./ ./
RUN npm install
CMD npm test
EXPOSE 3000

7
node_modules/jsbarcode/MIT-LICENSE.txt generated vendored Normal file
View File

@@ -0,0 +1,7 @@
Copyright (c) 2016 Johan Lindell (johan@lindell.me)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

255
node_modules/jsbarcode/README.md generated vendored Normal file
View File

@@ -0,0 +1,255 @@
<p align="center">
<a href="http://lindell.me/JsBarcode"><img src="http://lindell.me/JsBarcode/other/logo.svg" alt="JsBarcode"/></a>
<br><br>
<a href="http://travis-ci.org/lindell/JsBarcode"><img src="https://secure.travis-ci.org/lindell/JsBarcode.svg" alt="Build Status"/></a>
<a href="https://scrutinizer-ci.com/g/lindell/JsBarcode/?branch=master"><img src="https://scrutinizer-ci.com/g/lindell/JsBarcode/badges/quality-score.png?b=master" alt="Scrutinizer Code Quality"/></a>
<a href="https://www.jsdelivr.com/package/npm/jsbarcode"><img src="https://data.jsdelivr.com/v1/package/npm/jsbarcode/badge?style=rounded" alt="CDN"></a>
<a href="https://github.com/lindell/JsBarcode/blob/master/MIT-LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"/></a>
</p>
Introduction
----
**JsBarcode** is a **barcode generator** written in JavaScript. It supports multiple barcode formats and works in browsers and with *Node.js*. It has *no dependencies* when it is used for the web but works with *jQuery* if you are into that.
Demo
----
#### [Barcode Generator](http://lindell.github.io/JsBarcode/generator/)
#### [Simple CodePen Demo](http://codepen.io/lindell/pen/eZKBdO?editors=1010)
#### [Settings CodePen Demo](http://codepen.io/lindell/pen/mPvLXx?editors=1010)
Supported barcodes:
----
* [CODE128](https://github.com/lindell/JsBarcode/wiki/CODE128)
* CODE128 (automatic mode switching)
* CODE128 A/B/C (force mode)
* [EAN](https://github.com/lindell/JsBarcode/wiki/EAN)
* EAN-13
* EAN-8
* EAN-5
* EAN-2
* UPC (A)
* UPC (E)
* [CODE39](https://github.com/lindell/JsBarcode/wiki/CODE39)
* [ITF](https://github.com/lindell/JsBarcode/wiki/ITF-14)
* ITF
* ITF-14
* [MSI](https://github.com/lindell/JsBarcode/wiki/MSI)
* MSI10
* MSI11
* MSI1010
* MSI1110
* [Pharmacode](https://github.com/lindell/JsBarcode/wiki/pharmacode)
* [Codabar](https://github.com/lindell/JsBarcode/wiki/codabar)
Examples for browsers:
----
#### First create a canvas (or image)
````html
<svg id="barcode"></svg>
<!-- or -->
<canvas id="barcode"></canvas>
<!-- or -->
<img id="barcode"/>
````
#### Simple example:
````javascript
JsBarcode("#barcode", "Hi!");
// or with jQuery
$("#barcode").JsBarcode("Hi!");
````
##### Result:
![Result](https://s3-eu-west-1.amazonaws.com/js-barcode/barcodes/simple.svg)
#### Example with options:
````javascript
JsBarcode("#barcode", "1234", {
format: "pharmacode",
lineColor: "#0aa",
width:4,
height:40,
displayValue: false
});
````
##### Result:
![Result](https://s3-eu-west-1.amazonaws.com/js-barcode/barcodes/advanced.svg)
#### More advanced use case:
````javascript
JsBarcode("#barcode")
.options({font: "OCR-B"}) // Will affect all barcodes
.EAN13("1234567890128", {fontSize: 18, textMargin: 0})
.blank(20) // Create space between the barcodes
.EAN5("12345", {height: 85, textPosition: "top", fontSize: 16, marginTop: 15})
.render();
````
##### Result:
![Result](https://s3-eu-west-1.amazonaws.com/js-barcode/barcodes/simple.svg)
#### Or define the value and options in the HTML element:
Use any `jsbarcode-*` or `data-*` as attributes where `*` is any option.
````html
<svg class="barcode"
jsbarcode-format="upc"
jsbarcode-value="123456789012"
jsbarcode-textmargin="0"
jsbarcode-fontoptions="bold">
</svg>
````
And then initialize it with:
````javascript
JsBarcode(".barcode").init();
````
##### Result:
![Result](https://s3-eu-west-1.amazonaws.com/js-barcode/barcodes/init.svg)
#### Retrieve the barcode values so you can render it any way you'd like
Pass in an object which will be filled with data.
```javascript
const data = {};
JsBarcode(data, 'text', {...options});
```
data will be filled with a ``` encodings ``` property which has all the needed values.
See wiki for an example of what data looks like.
Setup for browsers:
----
### Step 1:
Download or get the CDN link to the script:
| Name | Supported barcodes | Size (gzip) | CDN / Download |
|------|--------------------|:-----------:|---------------:|
| *All* | *All the barcodes!* | *10.1 kB* | *[JsBarcode.all.min.js][1]* |
| CODE128 | CODE128 (auto and force mode) | 6.2 kB | [JsBarcode.code128.min.js][2] |
| CODE39 | CODE39 | 5.1 kB | [JsBarcode.code39.min.js][3] |
| EAN / UPC | EAN-13, EAN-8, EAN-5, EAN-2, UPC (A) | 6.7 kB | [JsBarcode.ean-upc.min.js][4] |
| ITF | ITF, ITF-14 | 5 kB | [JsBarcode.itf.min.js][5] |
| MSI | MSI, MSI10, MSI11, MSI1010, MSI1110 | 5 kB | [JsBarcode.msi.min.js][6] |
| Pharmacode | Pharmacode | 4.7 kB | [JsBarcode.pharmacode.min.js][7] |
| Codabar | Codabar | 4.9 kB | [JsBarcode.codabar.min.js][8] |
### Step 2:
Include the script in your code:
````html
<script src="JsBarcode.all.min.js"></script>
````
### Step 3:
You are done! Go generate some barcodes :smile:
Bower and npm:
----
You can also use [Bower](http://bower.io) or [npm](https://www.npmjs.com) to install and manage the library.
````bash
bower install jsbarcode --save
````
````bash
npm install jsbarcode --save
````
Node.js:
----
#### With canvas:
```` javascript
var JsBarcode = require('jsbarcode');
// Canvas v1
var Canvas = require("canvas");
// Canvas v2
var { createCanvas } = require("canvas");
// Canvas v1
var canvas = new Canvas();
// Canvas v2
var canvas = createCanvas();
JsBarcode(canvas, "Hello");
// Do what you want with the canvas
// See https://github.com/Automattic/node-canvas for more information
````
#### With svg:
```` javascript
const { DOMImplementation, XMLSerializer } = require('xmldom');
const xmlSerializer = new XMLSerializer();
const document = new DOMImplementation().createDocument('http://www.w3.org/1999/xhtml', 'html', null);
const svgNode = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
JsBarcode(svgNode, 'test', {
xmlDocument: document,
});
const svgText = xmlSerializer.serializeToString(svgNode);
````
Options:
----
For information about how to use the options, see [the wiki page](https://github.com/lindell/JsBarcode/wiki/Options).
| Option | Default value | Type |
|--------|---------------|------|
| [`format`](https://github.com/lindell/JsBarcode/wiki/Options#format) | `"auto" (CODE128)` | `String` |
| [`width`](https://github.com/lindell/JsBarcode/wiki/Options#width) | `2` | `Number` |
| [`height`](https://github.com/lindell/JsBarcode/wiki/Options#height) | `100` | `Number` |
| [`displayValue`](https://github.com/lindell/JsBarcode/wiki/Options#display-value) | `true` | `Boolean` |
| [`text`](https://github.com/lindell/JsBarcode/wiki/Options#text) | `undefined` | `String` |
| [`fontOptions`](https://github.com/lindell/JsBarcode/wiki/Options#font-options) | `""` | `String` |
| [`font`](https://github.com/lindell/JsBarcode/wiki/Options#font) | `"monospace"` | `String` |
| [`textAlign`](https://github.com/lindell/JsBarcode/wiki/Options#text-align) | `"center"` | `String` |
| [`textPosition`](https://github.com/lindell/JsBarcode/wiki/Options#text-position) | `"bottom"` | `String` |
| [`textMargin`](https://github.com/lindell/JsBarcode/wiki/Options#text-margin) | `2` | `Number` |
| [`fontSize`](https://github.com/lindell/JsBarcode/wiki/Options#font-size) | `20` | `Number` |
| [`background`](https://github.com/lindell/JsBarcode/wiki/Options#background) | `"#ffffff"` | `String (CSS color)` |
| [`lineColor`](https://github.com/lindell/JsBarcode/wiki/Options#line-color) | `"#000000"` | `String (CSS color)` |
| [`margin`](https://github.com/lindell/JsBarcode/wiki/Options#margins) | `10` | `Number` |
| [`marginTop`](https://github.com/lindell/JsBarcode/wiki/Options#margins) | `undefined` | `Number` |
| [`marginBottom`](https://github.com/lindell/JsBarcode/wiki/Options#margins) | `undefined` | `Number` |
| [`marginLeft`](https://github.com/lindell/JsBarcode/wiki/Options#margins) | `undefined` | `Number` |
| [`marginRight`](https://github.com/lindell/JsBarcode/wiki/Options#margins) | `undefined` | `Number` |
| [`valid`](https://github.com/lindell/JsBarcode/wiki/Options#valid) | `function(valid){}` | `Function` |
Contributions and feedback:
----
We :heart: contributions and feedback.
If you want to contribute, please check out the [CONTRIBUTING.md](https://github.com/lindell/JsBarcode/blob/master/CONTRIBUTING.md) file.
If you have any question or suggestion [create an issue](https://github.com/lindell/JsBarcode/issues/new) or ask about it in the [gitter chat](https://gitter.im/lindell/JsBarcode).
Bug reports should always be done with a [new issue](https://github.com/lindell/JsBarcode/issues/new).
License:
----
JsBarcode is shared under the [MIT license](https://github.com/lindell/JsBarcode/blob/master/MIT-LICENSE.txt). This means you can modify and use it however you want, even for comercial use. But please give this the Github repo a :star: and write a small comment of how you are using JsBarcode in the [gitter chat](https://gitter.im/lindell/JsBarcode).
[1]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/JsBarcode.all.min.js "jsdelivr all barcodes"
[2]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.code128.min.js "jsdelivr code128"
[3]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.code39.min.js "jsdelivr code39"
[4]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.ean-upc.min.js "jsdelivr ean/upc"
[5]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.itf.min.js "jsdelivr itf"
[6]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.msi.min.js "jsdelivr msi"
[7]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.pharmacode.min.js "jsdelivr pharmacode"
[8]: https://cdn.jsdelivr.net/npm/jsbarcode@3.11.0/dist/barcodes/JsBarcode.codabar.min.js "jsdelivr codabar"

View File

@@ -0,0 +1,37 @@
[
{
"name": "code39",
"names": "CODE39",
"barcodeFile": "./CODE39"
},
{
"name": "code128",
"names": ["CODE128, CODE128A, CODE128B, CODE128C"],
"barcodeFile": "./CODE128"
},
{
"name": "ean-upc",
"names": "EAN13, EAN8, EAN5, EAN2, UPC",
"barcodeFile": "./EAN_UPC"
},
{
"name": "itf",
"names": "ITF, ITF14",
"barcodeFile": "./ITF"
},
{
"name": "msi",
"names": "MSI, MSI10, MSI11, MSI1010, MSI1110",
"barcodeFile": "./MSI"
},
{
"name": "pharmacode",
"names": "pharmacode",
"barcodeFile": "./pharmacode"
},
{
"name": "codabar",
"names": "codabar",
"barcodeFile": "./codabar"
}
]

132
node_modules/jsbarcode/automation/building.js generated vendored Normal file
View File

@@ -0,0 +1,132 @@
var gulp = require('gulp');
var header = require('gulp-header');
var clean = require('gulp-clean');
var gulpWebpack = require('webpack-stream');
var webpack = require('webpack');
var babel = require("gulp-babel");
var runSequence = require('gulp4-run-sequence');
var fs = require('fs');
var settings = require('./settings.json');
var shared = require('./shared.js');
gulp.task("clean", gulp.series(function () {
return gulp.src(["bin/", "dist/"], { read: false })
.pipe(clean());
}));
gulp.task("babel", gulp.series(function () {
return babelFunc();
}));
function babelFunc() {
return gulp.src("src/**/*")
.pipe(babel({
presets: ['es2015', 'stage-3']
}))
.pipe(gulp.dest("bin/"));
}
gulp.task("webpack", gulp.series(["babel"], function () {
return webpackFunc();
}));
function webpackFunc() {
return gulp.src('bin/JsBarcode.js')
.pipe(gulpWebpack(
{
mode: "none",
output: {
filename: 'JsBarcode.all.js'
}
}
, webpack))
.pipe(gulp.dest("dist/"));
}
gulp.task("webpack-min", gulp.series(["babel"], function () {
return webpackMin('all');
}));
function webpackMin(name, dest) {
dest = dest || './';
return gulp.src('bin/JsBarcode.js')
.pipe(gulpWebpack(
{
mode: "production",
output: {
filename: shared.minifiedFilename(name)
},
}
, webpack))
.pipe(header(settings.banner, require(settings.baseDir + 'package.json')))
.pipe(gulp.dest("dist/" + dest));
}
gulp.task("webpack-all", gulp.series(function (cb) {
var barcodes = require('./barcode-building.json');
// Move the real barcodes/index.js out of the way while compiling the individual barcodes
fs.renameSync("src/barcodes/index.js", "src/barcodes/index.tmp.js");
// Take a barcode from the barcodes array, call the functions to compile that
// format and have a callback when it has finished.
function loopBarcode(i) {
if (i < barcodes.length) {
createBarcodeInclude(barcodes[i], function () {
loopBarcode(i + 1);
});
}
else {
fs.renameSync("src/barcodes/index.tmp.js", "src/barcodes/index.js");
cb(); // Done
}
}
loopBarcode(0);
}));
// Takes information about a barcode formatSize
// Modifies the barcodes/index.js file to only import the specified format
// and then does a recompilation and minifies everything with webpack
function createBarcodeInclude(barcode, callback) {
var toFile = "";
toFile += "import {" + barcode.names + "} from '" + barcode.barcodeFile + "'";
toFile += "\n";
toFile += "export default {" + barcode.names + "}";
// Write a new barcodes/index file that only includes the specified barcode
fs.writeFile("src/barcodes/index.js", toFile, function () {
// Remove the compiled barcodes/index file (if it exist)
if (fs.existsSync("bin/barcodes/index.js")) {
fs.unlinkSync("bin/barcodes/index.js");
}
// Re-compile with babel and webpack everything
babelFunc().on('end', function () {
webpackMin(barcode.name, 'barcodes/').on('end', callback);
});
});
}
gulp.task('compress', gulp.series(function (cb) {
runSequence(
"clean",
"webpack-all",
"webpack",
"webpack-min",
cb
);
}));
gulp.task('compile', gulp.series(['babel']));
gulp.task('compile-web', gulp.series(['webpack']));

9
node_modules/jsbarcode/automation/linting.js generated vendored Normal file
View File

@@ -0,0 +1,9 @@
var gulp = require('gulp');
var eslint = require('gulp-eslint');
gulp.task("lint", function () {
return gulp.src(['src/**/*.js'])
.pipe(eslint())
.pipe(eslint.format())
.pipe(eslint.failAfterError());
});

30
node_modules/jsbarcode/automation/misc.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
/*eslint no-console: 0 */
var gulp = require('gulp');
var request = require('request');
var fs = require('fs');
gulp.task('jsdelivr', function(callback){
console.log("Making request...");
request({
url: "https://api.jsdelivr.com/v1/jsdelivr/libraries?name=jsbarcode",
json: true
}, function (error, response, body) {
if (!error && response.statusCode === 200) {
var readme = fs.readFileSync('README.md', "utf-8");
var version = body[0].lastversion;
readme = readme.replace(/https:\/\/cdn\.jsdelivr\.net\/jsbarcode\/[0-9]+\.[0-9]+\.[0-9]+\//g,
"https://cdn.jsdelivr.net/jsbarcode/" + version + "/");
fs.writeFileSync('README.md', readme, 'utf8');
console.log("New version: " + version);
callback();
}
else{
console.error("Failed to make jsdelivr api request");
callback();
}
});
});

163
node_modules/jsbarcode/automation/releasing.js generated vendored Normal file
View File

@@ -0,0 +1,163 @@
/*eslint
no-console: 0
*/
var gulp = require('gulp');
var bump = require('gulp-bump');
var git = require('gulp-git');
var publishRelease = require('publish-release');
var gzipSize = require('gzip-size');
var runSequence = require('gulp4-run-sequence');
var fs = require('fs');
var settings = require('./settings.json');
var shared = require('./shared.js');
gulp.task('git-release', gulp.series(['compress'], function (cb) {
var pkg = require(settings.baseDir + 'package.json');
var v = 'v' + pkg.version;
var message = ':package: Release ' + v;
updateReadmeFileSizes();
gulp.src(['./package.json', './bower.json', './README.md', './bin/', './dist'])
.pipe(git.add({ args: '--all --force' }))
.pipe(git.commit(message));
git.push('origin', 'master', function () {
git.tag(v, message, function () {
git.push('origin', 'master', { args: '--tags' }, cb);
});
});
}));
// Bump (increase) the version number
gulp.task('bump-patch', function () {
return gulp.src(['./package.json', './bower.json'])
.pipe(bump({ type: 'patch' }))
.pipe(gulp.dest('./'));
});
gulp.task('bump-minor', function () {
return gulp.src(['./package.json', './bower.json'])
.pipe(bump({ type: 'minor' }))
.pipe(gulp.dest('./'));
});
gulp.task('bump-major', function () {
return gulp.src(['./package.json', './bower.json'])
.pipe(bump({ type: 'major' }))
.pipe(gulp.dest('./'));
});
gulp.task('npm', function (done) {
require('child_process').spawn('npm', ['publish'], { stdio: 'inherit' })
.on('close', done);
});
gulp.task('github-release', function (done) {
var pkg = require(settings.baseDir + './package.json');
var v = 'v' + pkg.version;
var name = "JsBarcode " + v;
publishRelease({
token: process.env.GITHUB_TOKEN,
owner: "lindell",
repo: "JsBarcode",
tag: v,
name: name,
assets: [__dirname + "/" + settings.baseDir + "/dist/JsBarcode.all.min.js", __dirname + "/" + settings.baseDir + "/dist/JsBarcode.all.js"]
}, done);
});
gulp.task('release', gulp.series(function (callback) {
runSequence(
'git-release',
'github-release',
'npm',
callback
);
}));
gulp.task('patch', function () {
runSequence(
'bump-patch',
'release',
releaseDone
);
});
gulp.task('minor', function () {
runSequence(
'bump-minor',
'release',
releaseDone
);
});
gulp.task('major', function () {
runSequence(
'bump-major',
'release',
releaseDone
);
});
function releaseDone(error) {
if (error) {
console.log(error.message);
}
else {
console.log('Successful!');
}
}
function updateReadmeFileSizes() {
var files = require('./barcode-building.json');
var readme = fs.readFileSync('README.md', "utf-8");
// Update .all files
var allData = fs.readFileSync('dist/JsBarcode.all.min.js');
var allFilesize = gzipSize.sync(allData);
var allRegexp = new RegExp('\\|[^\\|]*\\|([ \\t\\*]*\\[JsBarcode\\.all\\.min\\.js\\])');
readme = readme.replace(allRegexp, "| *" + formatSize(allFilesize) + "* |$1");
// Update all barcodes files
for (var i in files) {
var filename = shared.minifiedFilename(files[i].name);
var fileData = fs.readFileSync('dist/barcodes/' + filename);
var fileFilesize = gzipSize.sync(fileData);
var fileRegexp = new RegExp('\\|[^\\|]*\\|([ \\t]*\\[' + RegExp.escape(filename) + '\\])');
readme = readme.replace(fileRegexp, "| " + formatSize(fileFilesize) + " |$1");
}
fs.writeFileSync('README.md', readme, 'utf8');
}
// Util functions
RegExp.escape = function (s) {
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
};
function formatSize(bytes) {
var kilobytes = Math.round(bytes / 1024 * 10) / 10;
return kilobytes + " kB";
}

6
node_modules/jsbarcode/automation/settings.json generated vendored Normal file
View File

@@ -0,0 +1,6 @@
{
"baseDir": "../",
"distDir": "./dist/",
"binDir": "./bin/",
"banner": "/*! JsBarcode v<%= version %> | (c) <%= author %> | <%= license %> license */\n"
}

5
node_modules/jsbarcode/automation/shared.js generated vendored Normal file
View File

@@ -0,0 +1,5 @@
module.exports = {};
module.exports.minifiedFilename = function(name){
return "JsBarcode." + name + ".min.js";
};

252
node_modules/jsbarcode/bin/JsBarcode.js generated vendored Executable file
View File

@@ -0,0 +1,252 @@
'use strict';
var _barcodes = require('./barcodes/');
var _barcodes2 = _interopRequireDefault(_barcodes);
var _merge = require('./help/merge.js');
var _merge2 = _interopRequireDefault(_merge);
var _linearizeEncodings = require('./help/linearizeEncodings.js');
var _linearizeEncodings2 = _interopRequireDefault(_linearizeEncodings);
var _fixOptions = require('./help/fixOptions.js');
var _fixOptions2 = _interopRequireDefault(_fixOptions);
var _getRenderProperties = require('./help/getRenderProperties.js');
var _getRenderProperties2 = _interopRequireDefault(_getRenderProperties);
var _optionsFromStrings = require('./help/optionsFromStrings.js');
var _optionsFromStrings2 = _interopRequireDefault(_optionsFromStrings);
var _ErrorHandler = require('./exceptions/ErrorHandler.js');
var _ErrorHandler2 = _interopRequireDefault(_ErrorHandler);
var _exceptions = require('./exceptions/exceptions.js');
var _defaults = require('./options/defaults.js');
var _defaults2 = _interopRequireDefault(_defaults);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// The protype of the object returned from the JsBarcode() call
// Help functions
var API = function API() {};
// The first call of the library API
// Will return an object with all barcodes calls and the data that is used
// by the renderers
// Default values
// Exceptions
// Import all the barcodes
var JsBarcode = function JsBarcode(element, text, options) {
var api = new API();
if (typeof element === "undefined") {
throw Error("No element to render on was provided.");
}
// Variables that will be pased through the API calls
api._renderProperties = (0, _getRenderProperties2.default)(element);
api._encodings = [];
api._options = _defaults2.default;
api._errorHandler = new _ErrorHandler2.default(api);
// If text is set, use the simple syntax (render the barcode directly)
if (typeof text !== "undefined") {
options = options || {};
if (!options.format) {
options.format = autoSelectBarcode();
}
api.options(options)[options.format](text, options).render();
}
return api;
};
// To make tests work TODO: remove
JsBarcode.getModule = function (name) {
return _barcodes2.default[name];
};
// Register all barcodes
for (var name in _barcodes2.default) {
if (_barcodes2.default.hasOwnProperty(name)) {
// Security check if the propery is a prototype property
registerBarcode(_barcodes2.default, name);
}
}
function registerBarcode(barcodes, name) {
API.prototype[name] = API.prototype[name.toUpperCase()] = API.prototype[name.toLowerCase()] = function (text, options) {
var api = this;
return api._errorHandler.wrapBarcodeCall(function () {
// Ensure text is options.text
options.text = typeof options.text === 'undefined' ? undefined : '' + options.text;
var newOptions = (0, _merge2.default)(api._options, options);
newOptions = (0, _optionsFromStrings2.default)(newOptions);
var Encoder = barcodes[name];
var encoded = encode(text, Encoder, newOptions);
api._encodings.push(encoded);
return api;
});
};
}
// encode() handles the Encoder call and builds the binary string to be rendered
function encode(text, Encoder, options) {
// Ensure that text is a string
text = "" + text;
var encoder = new Encoder(text, options);
// If the input is not valid for the encoder, throw error.
// If the valid callback option is set, call it instead of throwing error
if (!encoder.valid()) {
throw new _exceptions.InvalidInputException(encoder.constructor.name, text);
}
// Make a request for the binary data (and other infromation) that should be rendered
var encoded = encoder.encode();
// Encodings can be nestled like [[1-1, 1-2], 2, [3-1, 3-2]
// Convert to [1-1, 1-2, 2, 3-1, 3-2]
encoded = (0, _linearizeEncodings2.default)(encoded);
// Merge
for (var i = 0; i < encoded.length; i++) {
encoded[i].options = (0, _merge2.default)(options, encoded[i].options);
}
return encoded;
}
function autoSelectBarcode() {
// If CODE128 exists. Use it
if (_barcodes2.default["CODE128"]) {
return "CODE128";
}
// Else, take the first (probably only) barcode
return Object.keys(_barcodes2.default)[0];
}
// Sets global encoder options
// Added to the api by the JsBarcode function
API.prototype.options = function (options) {
this._options = (0, _merge2.default)(this._options, options);
return this;
};
// Will create a blank space (usually in between barcodes)
API.prototype.blank = function (size) {
var zeroes = new Array(size + 1).join("0");
this._encodings.push({ data: zeroes });
return this;
};
// Initialize JsBarcode on all HTML elements defined.
API.prototype.init = function () {
// Should do nothing if no elements where found
if (!this._renderProperties) {
return;
}
// Make sure renderProperies is an array
if (!Array.isArray(this._renderProperties)) {
this._renderProperties = [this._renderProperties];
}
var renderProperty;
for (var i in this._renderProperties) {
renderProperty = this._renderProperties[i];
var options = (0, _merge2.default)(this._options, renderProperty.options);
if (options.format == "auto") {
options.format = autoSelectBarcode();
}
this._errorHandler.wrapBarcodeCall(function () {
var text = options.value;
var Encoder = _barcodes2.default[options.format.toUpperCase()];
var encoded = encode(text, Encoder, options);
render(renderProperty, encoded, options);
});
}
};
// The render API call. Calls the real render function.
API.prototype.render = function () {
if (!this._renderProperties) {
throw new _exceptions.NoElementException();
}
if (Array.isArray(this._renderProperties)) {
for (var i = 0; i < this._renderProperties.length; i++) {
render(this._renderProperties[i], this._encodings, this._options);
}
} else {
render(this._renderProperties, this._encodings, this._options);
}
return this;
};
API.prototype._defaults = _defaults2.default;
// Prepares the encodings and calls the renderer
function render(renderProperties, encodings, options) {
encodings = (0, _linearizeEncodings2.default)(encodings);
for (var i = 0; i < encodings.length; i++) {
encodings[i].options = (0, _merge2.default)(options, encodings[i].options);
(0, _fixOptions2.default)(encodings[i].options);
}
(0, _fixOptions2.default)(options);
var Renderer = renderProperties.renderer;
var renderer = new Renderer(renderProperties.element, encodings, options);
renderer.render();
if (renderProperties.afterRender) {
renderProperties.afterRender();
}
}
// Export to browser
if (typeof window !== "undefined") {
window.JsBarcode = JsBarcode;
}
// Export to jQuery
/*global jQuery */
if (typeof jQuery !== 'undefined') {
jQuery.fn.JsBarcode = function (content, options) {
var elementArray = [];
jQuery(this).each(function () {
elementArray.push(this);
});
return JsBarcode(elementArray, content, options);
};
}
// Export to commonJS
module.exports = JsBarcode;

17
node_modules/jsbarcode/bin/barcodes/Barcode.js generated vendored Executable file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Barcode = function Barcode(data, options) {
_classCallCheck(this, Barcode);
this.data = data;
this.text = options.text || data;
this.options = options;
};
exports.default = Barcode;

167
node_modules/jsbarcode/bin/barcodes/CODE128/CODE128.js generated vendored Executable file
View File

@@ -0,0 +1,167 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require('../Barcode.js');
var _Barcode3 = _interopRequireDefault(_Barcode2);
var _constants = require('./constants');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
// This is the master class,
// it does require the start code to be included in the string
var CODE128 = function (_Barcode) {
_inherits(CODE128, _Barcode);
function CODE128(data, options) {
_classCallCheck(this, CODE128);
// Get array of ascii codes from data
var _this = _possibleConstructorReturn(this, (CODE128.__proto__ || Object.getPrototypeOf(CODE128)).call(this, data.substring(1), options));
_this.bytes = data.split('').map(function (char) {
return char.charCodeAt(0);
});
return _this;
}
_createClass(CODE128, [{
key: 'valid',
value: function valid() {
// ASCII value ranges 0-127, 200-211
return (/^[\x00-\x7F\xC8-\xD3]+$/.test(this.data)
);
}
// The public encoding function
}, {
key: 'encode',
value: function encode() {
var bytes = this.bytes;
// Remove the start code from the bytes and set its index
var startIndex = bytes.shift() - 105;
// Get start set by index
var startSet = _constants.SET_BY_CODE[startIndex];
if (startSet === undefined) {
throw new RangeError('The encoding does not start with a start character.');
}
if (this.shouldEncodeAsEan128() === true) {
bytes.unshift(_constants.FNC1);
}
// Start encode with the right type
var encodingResult = CODE128.next(bytes, 1, startSet);
return {
text: this.text === this.data ? this.text.replace(/[^\x20-\x7E]/g, '') : this.text,
data:
// Add the start bits
CODE128.getBar(startIndex) +
// Add the encoded bits
encodingResult.result +
// Add the checksum
CODE128.getBar((encodingResult.checksum + startIndex) % _constants.MODULO) +
// Add the end bits
CODE128.getBar(_constants.STOP)
};
}
// GS1-128/EAN-128
}, {
key: 'shouldEncodeAsEan128',
value: function shouldEncodeAsEan128() {
var isEAN128 = this.options.ean128 || false;
if (typeof isEAN128 === 'string') {
isEAN128 = isEAN128.toLowerCase() === 'true';
}
return isEAN128;
}
// Get a bar symbol by index
}], [{
key: 'getBar',
value: function getBar(index) {
return _constants.BARS[index] ? _constants.BARS[index].toString() : '';
}
// Correct an index by a set and shift it from the bytes array
}, {
key: 'correctIndex',
value: function correctIndex(bytes, set) {
if (set === _constants.SET_A) {
var charCode = bytes.shift();
return charCode < 32 ? charCode + 64 : charCode - 32;
} else if (set === _constants.SET_B) {
return bytes.shift() - 32;
} else {
return (bytes.shift() - 48) * 10 + bytes.shift() - 48;
}
}
}, {
key: 'next',
value: function next(bytes, pos, set) {
if (!bytes.length) {
return { result: '', checksum: 0 };
}
var nextCode = void 0,
index = void 0;
// Special characters
if (bytes[0] >= 200) {
index = bytes.shift() - 105;
var nextSet = _constants.SWAP[index];
// Swap to other set
if (nextSet !== undefined) {
nextCode = CODE128.next(bytes, pos + 1, nextSet);
}
// Continue on current set but encode a special character
else {
// Shift
if ((set === _constants.SET_A || set === _constants.SET_B) && index === _constants.SHIFT) {
// Convert the next character so that is encoded correctly
bytes[0] = set === _constants.SET_A ? bytes[0] > 95 ? bytes[0] - 96 : bytes[0] : bytes[0] < 32 ? bytes[0] + 96 : bytes[0];
}
nextCode = CODE128.next(bytes, pos + 1, set);
}
}
// Continue encoding
else {
index = CODE128.correctIndex(bytes, set);
nextCode = CODE128.next(bytes, pos + 1, set);
}
// Get the correct binary encoding and calculate the weight
var enc = CODE128.getBar(index);
var weight = index * pos;
return {
result: enc + nextCode.result,
checksum: weight + nextCode.checksum
};
}
}]);
return CODE128;
}(_Barcode3.default);
exports.default = CODE128;

42
node_modules/jsbarcode/bin/barcodes/CODE128/CODE128A.js generated vendored Executable file
View File

@@ -0,0 +1,42 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _CODE2 = require('./CODE128.js');
var _CODE3 = _interopRequireDefault(_CODE2);
var _constants = require('./constants');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var CODE128A = function (_CODE) {
_inherits(CODE128A, _CODE);
function CODE128A(string, options) {
_classCallCheck(this, CODE128A);
return _possibleConstructorReturn(this, (CODE128A.__proto__ || Object.getPrototypeOf(CODE128A)).call(this, _constants.A_START_CHAR + string, options));
}
_createClass(CODE128A, [{
key: 'valid',
value: function valid() {
return new RegExp('^' + _constants.A_CHARS + '+$').test(this.data);
}
}]);
return CODE128A;
}(_CODE3.default);
exports.default = CODE128A;

42
node_modules/jsbarcode/bin/barcodes/CODE128/CODE128B.js generated vendored Executable file
View File

@@ -0,0 +1,42 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _CODE2 = require('./CODE128.js');
var _CODE3 = _interopRequireDefault(_CODE2);
var _constants = require('./constants');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var CODE128B = function (_CODE) {
_inherits(CODE128B, _CODE);
function CODE128B(string, options) {
_classCallCheck(this, CODE128B);
return _possibleConstructorReturn(this, (CODE128B.__proto__ || Object.getPrototypeOf(CODE128B)).call(this, _constants.B_START_CHAR + string, options));
}
_createClass(CODE128B, [{
key: 'valid',
value: function valid() {
return new RegExp('^' + _constants.B_CHARS + '+$').test(this.data);
}
}]);
return CODE128B;
}(_CODE3.default);
exports.default = CODE128B;

42
node_modules/jsbarcode/bin/barcodes/CODE128/CODE128C.js generated vendored Executable file
View File

@@ -0,0 +1,42 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _CODE2 = require('./CODE128.js');
var _CODE3 = _interopRequireDefault(_CODE2);
var _constants = require('./constants');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var CODE128C = function (_CODE) {
_inherits(CODE128C, _CODE);
function CODE128C(string, options) {
_classCallCheck(this, CODE128C);
return _possibleConstructorReturn(this, (CODE128C.__proto__ || Object.getPrototypeOf(CODE128C)).call(this, _constants.C_START_CHAR + string, options));
}
_createClass(CODE128C, [{
key: 'valid',
value: function valid() {
return new RegExp('^' + _constants.C_CHARS + '+$').test(this.data);
}
}]);
return CODE128C;
}(_CODE3.default);
exports.default = CODE128C;

41
node_modules/jsbarcode/bin/barcodes/CODE128/CODE128_AUTO.js generated vendored Executable file
View File

@@ -0,0 +1,41 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _CODE2 = require('./CODE128');
var _CODE3 = _interopRequireDefault(_CODE2);
var _auto = require('./auto');
var _auto2 = _interopRequireDefault(_auto);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var CODE128AUTO = function (_CODE) {
_inherits(CODE128AUTO, _CODE);
function CODE128AUTO(data, options) {
_classCallCheck(this, CODE128AUTO);
// ASCII value ranges 0-127, 200-211
if (/^[\x00-\x7F\xC8-\xD3]+$/.test(data)) {
var _this = _possibleConstructorReturn(this, (CODE128AUTO.__proto__ || Object.getPrototypeOf(CODE128AUTO)).call(this, (0, _auto2.default)(data), options));
} else {
var _this = _possibleConstructorReturn(this, (CODE128AUTO.__proto__ || Object.getPrototypeOf(CODE128AUTO)).call(this, data, options));
}
return _possibleConstructorReturn(_this);
}
return CODE128AUTO;
}(_CODE3.default);
exports.default = CODE128AUTO;

73
node_modules/jsbarcode/bin/barcodes/CODE128/auto.js generated vendored Executable file
View File

@@ -0,0 +1,73 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _constants = require('./constants');
// Match Set functions
var matchSetALength = function matchSetALength(string) {
return string.match(new RegExp('^' + _constants.A_CHARS + '*'))[0].length;
};
var matchSetBLength = function matchSetBLength(string) {
return string.match(new RegExp('^' + _constants.B_CHARS + '*'))[0].length;
};
var matchSetC = function matchSetC(string) {
return string.match(new RegExp('^' + _constants.C_CHARS + '*'))[0];
};
// CODE128A or CODE128B
function autoSelectFromAB(string, isA) {
var ranges = isA ? _constants.A_CHARS : _constants.B_CHARS;
var untilC = string.match(new RegExp('^(' + ranges + '+?)(([0-9]{2}){2,})([^0-9]|$)'));
if (untilC) {
return untilC[1] + String.fromCharCode(204) + autoSelectFromC(string.substring(untilC[1].length));
}
var chars = string.match(new RegExp('^' + ranges + '+'))[0];
if (chars.length === string.length) {
return string;
}
return chars + String.fromCharCode(isA ? 205 : 206) + autoSelectFromAB(string.substring(chars.length), !isA);
}
// CODE128C
function autoSelectFromC(string) {
var cMatch = matchSetC(string);
var length = cMatch.length;
if (length === string.length) {
return string;
}
string = string.substring(length);
// Select A/B depending on the longest match
var isA = matchSetALength(string) >= matchSetBLength(string);
return cMatch + String.fromCharCode(isA ? 206 : 205) + autoSelectFromAB(string, isA);
}
// Detect Code Set (A, B or C) and format the string
exports.default = function (string) {
var newString = void 0;
var cLength = matchSetC(string).length;
// Select 128C if the string start with enough digits
if (cLength >= 2) {
newString = _constants.C_START_CHAR + autoSelectFromC(string);
} else {
// Select A/B depending on the longest match
var isA = matchSetALength(string) > matchSetBLength(string);
newString = (isA ? _constants.A_START_CHAR : _constants.B_START_CHAR) + autoSelectFromAB(string, isA);
}
return newString.replace(/[\xCD\xCE]([^])[\xCD\xCE]/, // Any sequence between 205 and 206 characters
function (match, char) {
return String.fromCharCode(203) + char;
});
};

View File

@@ -0,0 +1,54 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _SET_BY_CODE;
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
// constants for internal usage
var SET_A = exports.SET_A = 0;
var SET_B = exports.SET_B = 1;
var SET_C = exports.SET_C = 2;
// Special characters
var SHIFT = exports.SHIFT = 98;
var START_A = exports.START_A = 103;
var START_B = exports.START_B = 104;
var START_C = exports.START_C = 105;
var MODULO = exports.MODULO = 103;
var STOP = exports.STOP = 106;
var FNC1 = exports.FNC1 = 207;
// Get set by start code
var SET_BY_CODE = exports.SET_BY_CODE = (_SET_BY_CODE = {}, _defineProperty(_SET_BY_CODE, START_A, SET_A), _defineProperty(_SET_BY_CODE, START_B, SET_B), _defineProperty(_SET_BY_CODE, START_C, SET_C), _SET_BY_CODE);
// Get next set by code
var SWAP = exports.SWAP = {
101: SET_A,
100: SET_B,
99: SET_C
};
var A_START_CHAR = exports.A_START_CHAR = String.fromCharCode(208); // START_A + 105
var B_START_CHAR = exports.B_START_CHAR = String.fromCharCode(209); // START_B + 105
var C_START_CHAR = exports.C_START_CHAR = String.fromCharCode(210); // START_C + 105
// 128A (Code Set A)
// ASCII characters 00 to 95 (09, AZ and control codes), special characters, and FNC 14
var A_CHARS = exports.A_CHARS = "[\x00-\x5F\xC8-\xCF]";
// 128B (Code Set B)
// ASCII characters 32 to 127 (09, AZ, az), special characters, and FNC 14
var B_CHARS = exports.B_CHARS = "[\x20-\x7F\xC8-\xCF]";
// 128C (Code Set C)
// 0099 (encodes two digits with a single code point) and FNC1
var C_CHARS = exports.C_CHARS = "(\xCF*[0-9]{2}\xCF*)";
// CODE128 includes 107 symbols:
// 103 data symbols, 3 start symbols (A, B and C), and 1 stop symbol (the last one)
// Each symbol consist of three black bars (1) and three white spaces (0).
var BARS = exports.BARS = [11011001100, 11001101100, 11001100110, 10010011000, 10010001100, 10001001100, 10011001000, 10011000100, 10001100100, 11001001000, 11001000100, 11000100100, 10110011100, 10011011100, 10011001110, 10111001100, 10011101100, 10011100110, 11001110010, 11001011100, 11001001110, 11011100100, 11001110100, 11101101110, 11101001100, 11100101100, 11100100110, 11101100100, 11100110100, 11100110010, 11011011000, 11011000110, 11000110110, 10100011000, 10001011000, 10001000110, 10110001000, 10001101000, 10001100010, 11010001000, 11000101000, 11000100010, 10110111000, 10110001110, 10001101110, 10111011000, 10111000110, 10001110110, 11101110110, 11010001110, 11000101110, 11011101000, 11011100010, 11011101110, 11101011000, 11101000110, 11100010110, 11101101000, 11101100010, 11100011010, 11101111010, 11001000010, 11110001010, 10100110000, 10100001100, 10010110000, 10010000110, 10000101100, 10000100110, 10110010000, 10110000100, 10011010000, 10011000010, 10000110100, 10000110010, 11000010010, 11001010000, 11110111010, 11000010100, 10001111010, 10100111100, 10010111100, 10010011110, 10111100100, 10011110100, 10011110010, 11110100100, 11110010100, 11110010010, 11011011110, 11011110110, 11110110110, 10101111000, 10100011110, 10001011110, 10111101000, 10111100010, 11110101000, 11110100010, 10111011110, 10111101110, 11101011110, 11110101110, 11010000100, 11010010000, 11010011100, 1100011101011];

29
node_modules/jsbarcode/bin/barcodes/CODE128/index.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.CODE128C = exports.CODE128B = exports.CODE128A = exports.CODE128 = undefined;
var _CODE128_AUTO = require('./CODE128_AUTO.js');
var _CODE128_AUTO2 = _interopRequireDefault(_CODE128_AUTO);
var _CODE128A = require('./CODE128A.js');
var _CODE128A2 = _interopRequireDefault(_CODE128A);
var _CODE128B = require('./CODE128B.js');
var _CODE128B2 = _interopRequireDefault(_CODE128B);
var _CODE128C = require('./CODE128C.js');
var _CODE128C2 = _interopRequireDefault(_CODE128C);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.CODE128 = _CODE128_AUTO2.default;
exports.CODE128A = _CODE128A2.default;
exports.CODE128B = _CODE128B2.default;
exports.CODE128C = _CODE128C2.default;

105
node_modules/jsbarcode/bin/barcodes/CODE39/index.js generated vendored Normal file
View File

@@ -0,0 +1,105 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.CODE39 = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/Code_39#Encoding
var CODE39 = function (_Barcode) {
_inherits(CODE39, _Barcode);
function CODE39(data, options) {
_classCallCheck(this, CODE39);
data = data.toUpperCase();
// Calculate mod43 checksum if enabled
if (options.mod43) {
data += getCharacter(mod43checksum(data));
}
return _possibleConstructorReturn(this, (CODE39.__proto__ || Object.getPrototypeOf(CODE39)).call(this, data, options));
}
_createClass(CODE39, [{
key: "encode",
value: function encode() {
// First character is always a *
var result = getEncoding("*");
// Take every character and add the binary representation to the result
for (var i = 0; i < this.data.length; i++) {
result += getEncoding(this.data[i]) + "0";
}
// Last character is always a *
result += getEncoding("*");
return {
data: result,
text: this.text
};
}
}, {
key: "valid",
value: function valid() {
return this.data.search(/^[0-9A-Z\-\.\ \$\/\+\%]+$/) !== -1;
}
}]);
return CODE39;
}(_Barcode3.default);
// All characters. The position in the array is the (checksum) value
var characters = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "-", ".", " ", "$", "/", "+", "%", "*"];
// The decimal representation of the characters, is converted to the
// corresponding binary with the getEncoding function
var encodings = [20957, 29783, 23639, 30485, 20951, 29813, 23669, 20855, 29789, 23645, 29975, 23831, 30533, 22295, 30149, 24005, 21623, 29981, 23837, 22301, 30023, 23879, 30545, 22343, 30161, 24017, 21959, 30065, 23921, 22385, 29015, 18263, 29141, 17879, 29045, 18293, 17783, 29021, 18269, 17477, 17489, 17681, 20753, 35770];
// Get the binary representation of a character by converting the encodings
// from decimal to binary
function getEncoding(character) {
return getBinary(characterValue(character));
}
function getBinary(characterValue) {
return encodings[characterValue].toString(2);
}
function getCharacter(characterValue) {
return characters[characterValue];
}
function characterValue(character) {
return characters.indexOf(character);
}
function mod43checksum(data) {
var checksum = 0;
for (var i = 0; i < data.length; i++) {
checksum += characterValue(data[i]);
}
checksum = checksum % 43;
return checksum;
}
exports.CODE39 = CODE39;

92
node_modules/jsbarcode/bin/barcodes/EAN_UPC/EAN.js generated vendored Executable file
View File

@@ -0,0 +1,92 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _constants = require('./constants');
var _encoder = require('./encoder');
var _encoder2 = _interopRequireDefault(_encoder);
var _Barcode2 = require('../Barcode');
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
// Base class for EAN8 & EAN13
var EAN = function (_Barcode) {
_inherits(EAN, _Barcode);
function EAN(data, options) {
_classCallCheck(this, EAN);
// Make sure the font is not bigger than the space between the guard bars
var _this = _possibleConstructorReturn(this, (EAN.__proto__ || Object.getPrototypeOf(EAN)).call(this, data, options));
_this.fontSize = !options.flat && options.fontSize > options.width * 10 ? options.width * 10 : options.fontSize;
// Make the guard bars go down half the way of the text
_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
return _this;
}
_createClass(EAN, [{
key: 'encode',
value: function encode() {
return this.options.flat ? this.encodeFlat() : this.encodeGuarded();
}
}, {
key: 'leftText',
value: function leftText(from, to) {
return this.text.substr(from, to);
}
}, {
key: 'leftEncode',
value: function leftEncode(data, structure) {
return (0, _encoder2.default)(data, structure);
}
}, {
key: 'rightText',
value: function rightText(from, to) {
return this.text.substr(from, to);
}
}, {
key: 'rightEncode',
value: function rightEncode(data, structure) {
return (0, _encoder2.default)(data, structure);
}
}, {
key: 'encodeGuarded',
value: function encodeGuarded() {
var textOptions = { fontSize: this.fontSize };
var guardOptions = { height: this.guardHeight };
return [{ data: _constants.SIDE_BIN, options: guardOptions }, { data: this.leftEncode(), text: this.leftText(), options: textOptions }, { data: _constants.MIDDLE_BIN, options: guardOptions }, { data: this.rightEncode(), text: this.rightText(), options: textOptions }, { data: _constants.SIDE_BIN, options: guardOptions }];
}
}, {
key: 'encodeFlat',
value: function encodeFlat() {
var data = [_constants.SIDE_BIN, this.leftEncode(), _constants.MIDDLE_BIN, this.rightEncode(), _constants.SIDE_BIN];
return {
data: data.join(''),
text: this.text
};
}
}]);
return EAN;
}(_Barcode3.default);
exports.default = EAN;

119
node_modules/jsbarcode/bin/barcodes/EAN_UPC/EAN13.js generated vendored Executable file
View File

@@ -0,0 +1,119 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _constants = require('./constants');
var _EAN2 = require('./EAN');
var _EAN3 = _interopRequireDefault(_EAN2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Binary_encoding_of_data_digits_into_EAN-13_barcode
// Calculate the checksum digit
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Calculation_of_checksum_digit
var checksum = function checksum(number) {
var res = number.substr(0, 12).split('').map(function (n) {
return +n;
}).reduce(function (sum, a, idx) {
return idx % 2 ? sum + a * 3 : sum + a;
}, 0);
return (10 - res % 10) % 10;
};
var EAN13 = function (_EAN) {
_inherits(EAN13, _EAN);
function EAN13(data, options) {
_classCallCheck(this, EAN13);
// Add checksum if it does not exist
if (data.search(/^[0-9]{12}$/) !== -1) {
data += checksum(data);
}
// Adds a last character to the end of the barcode
var _this = _possibleConstructorReturn(this, (EAN13.__proto__ || Object.getPrototypeOf(EAN13)).call(this, data, options));
_this.lastChar = options.lastChar;
return _this;
}
_createClass(EAN13, [{
key: 'valid',
value: function valid() {
return this.data.search(/^[0-9]{13}$/) !== -1 && +this.data[12] === checksum(this.data);
}
}, {
key: 'leftText',
value: function leftText() {
return _get(EAN13.prototype.__proto__ || Object.getPrototypeOf(EAN13.prototype), 'leftText', this).call(this, 1, 6);
}
}, {
key: 'leftEncode',
value: function leftEncode() {
var data = this.data.substr(1, 6);
var structure = _constants.EAN13_STRUCTURE[this.data[0]];
return _get(EAN13.prototype.__proto__ || Object.getPrototypeOf(EAN13.prototype), 'leftEncode', this).call(this, data, structure);
}
}, {
key: 'rightText',
value: function rightText() {
return _get(EAN13.prototype.__proto__ || Object.getPrototypeOf(EAN13.prototype), 'rightText', this).call(this, 7, 6);
}
}, {
key: 'rightEncode',
value: function rightEncode() {
var data = this.data.substr(7, 6);
return _get(EAN13.prototype.__proto__ || Object.getPrototypeOf(EAN13.prototype), 'rightEncode', this).call(this, data, 'RRRRRR');
}
// The "standard" way of printing EAN13 barcodes with guard bars
}, {
key: 'encodeGuarded',
value: function encodeGuarded() {
var data = _get(EAN13.prototype.__proto__ || Object.getPrototypeOf(EAN13.prototype), 'encodeGuarded', this).call(this);
// Extend data with left digit & last character
if (this.options.displayValue) {
data.unshift({
data: '000000000000',
text: this.text.substr(0, 1),
options: { textAlign: 'left', fontSize: this.fontSize }
});
if (this.options.lastChar) {
data.push({
data: '00'
});
data.push({
data: '00000',
text: this.options.lastChar,
options: { fontSize: this.fontSize }
});
}
}
return data;
}
}]);
return EAN13;
}(_EAN3.default);
exports.default = EAN13;

58
node_modules/jsbarcode/bin/barcodes/EAN_UPC/EAN2.js generated vendored Executable file
View File

@@ -0,0 +1,58 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _constants = require('./constants');
var _encoder = require('./encoder');
var _encoder2 = _interopRequireDefault(_encoder);
var _Barcode2 = require('../Barcode');
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/EAN_2#Encoding
var EAN2 = function (_Barcode) {
_inherits(EAN2, _Barcode);
function EAN2(data, options) {
_classCallCheck(this, EAN2);
return _possibleConstructorReturn(this, (EAN2.__proto__ || Object.getPrototypeOf(EAN2)).call(this, data, options));
}
_createClass(EAN2, [{
key: 'valid',
value: function valid() {
return this.data.search(/^[0-9]{2}$/) !== -1;
}
}, {
key: 'encode',
value: function encode() {
// Choose the structure based on the number mod 4
var structure = _constants.EAN2_STRUCTURE[parseInt(this.data) % 4];
return {
// Start bits + Encode the two digits with 01 in between
data: '1011' + (0, _encoder2.default)(this.data, structure, '01'),
text: this.text
};
}
}]);
return EAN2;
}(_Barcode3.default);
exports.default = EAN2;

65
node_modules/jsbarcode/bin/barcodes/EAN_UPC/EAN5.js generated vendored Executable file
View File

@@ -0,0 +1,65 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _constants = require('./constants');
var _encoder = require('./encoder');
var _encoder2 = _interopRequireDefault(_encoder);
var _Barcode2 = require('../Barcode');
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/EAN_5#Encoding
var checksum = function checksum(data) {
var result = data.split('').map(function (n) {
return +n;
}).reduce(function (sum, a, idx) {
return idx % 2 ? sum + a * 9 : sum + a * 3;
}, 0);
return result % 10;
};
var EAN5 = function (_Barcode) {
_inherits(EAN5, _Barcode);
function EAN5(data, options) {
_classCallCheck(this, EAN5);
return _possibleConstructorReturn(this, (EAN5.__proto__ || Object.getPrototypeOf(EAN5)).call(this, data, options));
}
_createClass(EAN5, [{
key: 'valid',
value: function valid() {
return this.data.search(/^[0-9]{5}$/) !== -1;
}
}, {
key: 'encode',
value: function encode() {
var structure = _constants.EAN5_STRUCTURE[checksum(this.data)];
return {
data: '1011' + (0, _encoder2.default)(this.data, structure, '01'),
text: this.text
};
}
}]);
return EAN5;
}(_Barcode3.default);
exports.default = EAN5;

81
node_modules/jsbarcode/bin/barcodes/EAN_UPC/EAN8.js generated vendored Executable file
View File

@@ -0,0 +1,81 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _EAN2 = require('./EAN');
var _EAN3 = _interopRequireDefault(_EAN2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// http://www.barcodeisland.com/ean8.phtml
// Calculate the checksum digit
var checksum = function checksum(number) {
var res = number.substr(0, 7).split('').map(function (n) {
return +n;
}).reduce(function (sum, a, idx) {
return idx % 2 ? sum + a : sum + a * 3;
}, 0);
return (10 - res % 10) % 10;
};
var EAN8 = function (_EAN) {
_inherits(EAN8, _EAN);
function EAN8(data, options) {
_classCallCheck(this, EAN8);
// Add checksum if it does not exist
if (data.search(/^[0-9]{7}$/) !== -1) {
data += checksum(data);
}
return _possibleConstructorReturn(this, (EAN8.__proto__ || Object.getPrototypeOf(EAN8)).call(this, data, options));
}
_createClass(EAN8, [{
key: 'valid',
value: function valid() {
return this.data.search(/^[0-9]{8}$/) !== -1 && +this.data[7] === checksum(this.data);
}
}, {
key: 'leftText',
value: function leftText() {
return _get(EAN8.prototype.__proto__ || Object.getPrototypeOf(EAN8.prototype), 'leftText', this).call(this, 0, 4);
}
}, {
key: 'leftEncode',
value: function leftEncode() {
var data = this.data.substr(0, 4);
return _get(EAN8.prototype.__proto__ || Object.getPrototypeOf(EAN8.prototype), 'leftEncode', this).call(this, data, 'LLLL');
}
}, {
key: 'rightText',
value: function rightText() {
return _get(EAN8.prototype.__proto__ || Object.getPrototypeOf(EAN8.prototype), 'rightText', this).call(this, 4, 4);
}
}, {
key: 'rightEncode',
value: function rightEncode() {
var data = this.data.substr(4, 4);
return _get(EAN8.prototype.__proto__ || Object.getPrototypeOf(EAN8.prototype), 'rightEncode', this).call(this, data, 'RRRR');
}
}]);
return EAN8;
}(_EAN3.default);
exports.default = EAN8;

165
node_modules/jsbarcode/bin/barcodes/EAN_UPC/UPC.js generated vendored Executable file
View File

@@ -0,0 +1,165 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
exports.checksum = checksum;
var _encoder = require("./encoder");
var _encoder2 = _interopRequireDefault(_encoder);
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#Encoding
var UPC = function (_Barcode) {
_inherits(UPC, _Barcode);
function UPC(data, options) {
_classCallCheck(this, UPC);
// Add checksum if it does not exist
if (data.search(/^[0-9]{11}$/) !== -1) {
data += checksum(data);
}
var _this = _possibleConstructorReturn(this, (UPC.__proto__ || Object.getPrototypeOf(UPC)).call(this, data, options));
_this.displayValue = options.displayValue;
// Make sure the font is not bigger than the space between the guard bars
if (options.fontSize > options.width * 10) {
_this.fontSize = options.width * 10;
} else {
_this.fontSize = options.fontSize;
}
// Make the guard bars go down half the way of the text
_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
return _this;
}
_createClass(UPC, [{
key: "valid",
value: function valid() {
return this.data.search(/^[0-9]{12}$/) !== -1 && this.data[11] == checksum(this.data);
}
}, {
key: "encode",
value: function encode() {
if (this.options.flat) {
return this.flatEncoding();
} else {
return this.guardedEncoding();
}
}
}, {
key: "flatEncoding",
value: function flatEncoding() {
var result = "";
result += "101";
result += (0, _encoder2.default)(this.data.substr(0, 6), "LLLLLL");
result += "01010";
result += (0, _encoder2.default)(this.data.substr(6, 6), "RRRRRR");
result += "101";
return {
data: result,
text: this.text
};
}
}, {
key: "guardedEncoding",
value: function guardedEncoding() {
var result = [];
// Add the first digit
if (this.displayValue) {
result.push({
data: "00000000",
text: this.text.substr(0, 1),
options: { textAlign: "left", fontSize: this.fontSize }
});
}
// Add the guard bars
result.push({
data: "101" + (0, _encoder2.default)(this.data[0], "L"),
options: { height: this.guardHeight }
});
// Add the left side
result.push({
data: (0, _encoder2.default)(this.data.substr(1, 5), "LLLLL"),
text: this.text.substr(1, 5),
options: { fontSize: this.fontSize }
});
// Add the middle bits
result.push({
data: "01010",
options: { height: this.guardHeight }
});
// Add the right side
result.push({
data: (0, _encoder2.default)(this.data.substr(6, 5), "RRRRR"),
text: this.text.substr(6, 5),
options: { fontSize: this.fontSize }
});
// Add the end bits
result.push({
data: (0, _encoder2.default)(this.data[11], "R") + "101",
options: { height: this.guardHeight }
});
// Add the last digit
if (this.displayValue) {
result.push({
data: "00000000",
text: this.text.substr(11, 1),
options: { textAlign: "right", fontSize: this.fontSize }
});
}
return result;
}
}]);
return UPC;
}(_Barcode3.default);
// Calulate the checksum digit
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Calculation_of_checksum_digit
function checksum(number) {
var result = 0;
var i;
for (i = 1; i < 11; i += 2) {
result += parseInt(number[i]);
}
for (i = 0; i < 11; i += 2) {
result += parseInt(number[i]) * 3;
}
return (10 - result % 10) % 10;
}
exports.default = UPC;

185
node_modules/jsbarcode/bin/barcodes/EAN_UPC/UPCE.js generated vendored Executable file
View File

@@ -0,0 +1,185 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _encoder = require('./encoder');
var _encoder2 = _interopRequireDefault(_encoder);
var _Barcode2 = require('../Barcode.js');
var _Barcode3 = _interopRequireDefault(_Barcode2);
var _UPC = require('./UPC.js');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#Encoding
//
// UPC-E documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#UPC-E
var EXPANSIONS = ["XX00000XXX", "XX10000XXX", "XX20000XXX", "XXX00000XX", "XXXX00000X", "XXXXX00005", "XXXXX00006", "XXXXX00007", "XXXXX00008", "XXXXX00009"];
var PARITIES = [["EEEOOO", "OOOEEE"], ["EEOEOO", "OOEOEE"], ["EEOOEO", "OOEEOE"], ["EEOOOE", "OOEEEO"], ["EOEEOO", "OEOOEE"], ["EOOEEO", "OEEOOE"], ["EOOOEE", "OEEEOO"], ["EOEOEO", "OEOEOE"], ["EOEOOE", "OEOEEO"], ["EOOEOE", "OEEOEO"]];
var UPCE = function (_Barcode) {
_inherits(UPCE, _Barcode);
function UPCE(data, options) {
_classCallCheck(this, UPCE);
var _this = _possibleConstructorReturn(this, (UPCE.__proto__ || Object.getPrototypeOf(UPCE)).call(this, data, options));
// Code may be 6 or 8 digits;
// A 7 digit code is ambiguous as to whether the extra digit
// is a UPC-A check or number system digit.
_this.isValid = false;
if (data.search(/^[0-9]{6}$/) !== -1) {
_this.middleDigits = data;
_this.upcA = expandToUPCA(data, "0");
_this.text = options.text || '' + _this.upcA[0] + data + _this.upcA[_this.upcA.length - 1];
_this.isValid = true;
} else if (data.search(/^[01][0-9]{7}$/) !== -1) {
_this.middleDigits = data.substring(1, data.length - 1);
_this.upcA = expandToUPCA(_this.middleDigits, data[0]);
if (_this.upcA[_this.upcA.length - 1] === data[data.length - 1]) {
_this.isValid = true;
} else {
// checksum mismatch
return _possibleConstructorReturn(_this);
}
} else {
return _possibleConstructorReturn(_this);
}
_this.displayValue = options.displayValue;
// Make sure the font is not bigger than the space between the guard bars
if (options.fontSize > options.width * 10) {
_this.fontSize = options.width * 10;
} else {
_this.fontSize = options.fontSize;
}
// Make the guard bars go down half the way of the text
_this.guardHeight = options.height + _this.fontSize / 2 + options.textMargin;
return _this;
}
_createClass(UPCE, [{
key: 'valid',
value: function valid() {
return this.isValid;
}
}, {
key: 'encode',
value: function encode() {
if (this.options.flat) {
return this.flatEncoding();
} else {
return this.guardedEncoding();
}
}
}, {
key: 'flatEncoding',
value: function flatEncoding() {
var result = "";
result += "101";
result += this.encodeMiddleDigits();
result += "010101";
return {
data: result,
text: this.text
};
}
}, {
key: 'guardedEncoding',
value: function guardedEncoding() {
var result = [];
// Add the UPC-A number system digit beneath the quiet zone
if (this.displayValue) {
result.push({
data: "00000000",
text: this.text[0],
options: { textAlign: "left", fontSize: this.fontSize }
});
}
// Add the guard bars
result.push({
data: "101",
options: { height: this.guardHeight }
});
// Add the 6 UPC-E digits
result.push({
data: this.encodeMiddleDigits(),
text: this.text.substring(1, 7),
options: { fontSize: this.fontSize }
});
// Add the end bits
result.push({
data: "010101",
options: { height: this.guardHeight }
});
// Add the UPC-A check digit beneath the quiet zone
if (this.displayValue) {
result.push({
data: "00000000",
text: this.text[7],
options: { textAlign: "right", fontSize: this.fontSize }
});
}
return result;
}
}, {
key: 'encodeMiddleDigits',
value: function encodeMiddleDigits() {
var numberSystem = this.upcA[0];
var checkDigit = this.upcA[this.upcA.length - 1];
var parity = PARITIES[parseInt(checkDigit)][parseInt(numberSystem)];
return (0, _encoder2.default)(this.middleDigits, parity);
}
}]);
return UPCE;
}(_Barcode3.default);
function expandToUPCA(middleDigits, numberSystem) {
var lastUpcE = parseInt(middleDigits[middleDigits.length - 1]);
var expansion = EXPANSIONS[lastUpcE];
var result = "";
var digitIndex = 0;
for (var i = 0; i < expansion.length; i++) {
var c = expansion[i];
if (c === 'X') {
result += middleDigits[digitIndex++];
} else {
result += c;
}
}
result = '' + numberSystem + result;
return '' + result + (0, _UPC.checksum)(result);
}
exports.default = UPCE;

View File

@@ -0,0 +1,30 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
// Standard start end and middle bits
var SIDE_BIN = exports.SIDE_BIN = '101';
var MIDDLE_BIN = exports.MIDDLE_BIN = '01010';
var BINARIES = exports.BINARIES = {
'L': [// The L (left) type of encoding
'0001101', '0011001', '0010011', '0111101', '0100011', '0110001', '0101111', '0111011', '0110111', '0001011'],
'G': [// The G type of encoding
'0100111', '0110011', '0011011', '0100001', '0011101', '0111001', '0000101', '0010001', '0001001', '0010111'],
'R': [// The R (right) type of encoding
'1110010', '1100110', '1101100', '1000010', '1011100', '1001110', '1010000', '1000100', '1001000', '1110100'],
'O': [// The O (odd) encoding for UPC-E
'0001101', '0011001', '0010011', '0111101', '0100011', '0110001', '0101111', '0111011', '0110111', '0001011'],
'E': [// The E (even) encoding for UPC-E
'0100111', '0110011', '0011011', '0100001', '0011101', '0111001', '0000101', '0010001', '0001001', '0010111']
};
// Define the EAN-2 structure
var EAN2_STRUCTURE = exports.EAN2_STRUCTURE = ['LL', 'LG', 'GL', 'GG'];
// Define the EAN-5 structure
var EAN5_STRUCTURE = exports.EAN5_STRUCTURE = ['GGLLL', 'GLGLL', 'GLLGL', 'GLLLG', 'LGGLL', 'LLGGL', 'LLLGG', 'LGLGL', 'LGLLG', 'LLGLG'];
// Define the EAN-13 structure
var EAN13_STRUCTURE = exports.EAN13_STRUCTURE = ['LLLLLL', 'LLGLGG', 'LLGGLG', 'LLGGGL', 'LGLLGG', 'LGGLLG', 'LGGGLL', 'LGLGLG', 'LGLGGL', 'LGGLGL'];

27
node_modules/jsbarcode/bin/barcodes/EAN_UPC/encoder.js generated vendored Executable file
View File

@@ -0,0 +1,27 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _constants = require('./constants');
// Encode data string
var encode = function encode(data, structure, separator) {
var encoded = data.split('').map(function (val, idx) {
return _constants.BINARIES[structure[idx]];
}).map(function (val, idx) {
return val ? val[data[idx]] : '';
});
if (separator) {
var last = data.length - 1;
encoded = encoded.map(function (val, idx) {
return idx < last ? val + separator : val;
});
}
return encoded.join('');
};
exports.default = encode;

39
node_modules/jsbarcode/bin/barcodes/EAN_UPC/index.js generated vendored Normal file
View File

@@ -0,0 +1,39 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.UPCE = exports.UPC = exports.EAN2 = exports.EAN5 = exports.EAN8 = exports.EAN13 = undefined;
var _EAN = require('./EAN13.js');
var _EAN2 = _interopRequireDefault(_EAN);
var _EAN3 = require('./EAN8.js');
var _EAN4 = _interopRequireDefault(_EAN3);
var _EAN5 = require('./EAN5.js');
var _EAN6 = _interopRequireDefault(_EAN5);
var _EAN7 = require('./EAN2.js');
var _EAN8 = _interopRequireDefault(_EAN7);
var _UPC = require('./UPC.js');
var _UPC2 = _interopRequireDefault(_UPC);
var _UPCE = require('./UPCE.js');
var _UPCE2 = _interopRequireDefault(_UPCE);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.EAN13 = _EAN2.default;
exports.EAN8 = _EAN4.default;
exports.EAN5 = _EAN6.default;
exports.EAN2 = _EAN8.default;
exports.UPC = _UPC2.default;
exports.UPCE = _UPCE2.default;

View File

@@ -0,0 +1,55 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.GenericBarcode = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var GenericBarcode = function (_Barcode) {
_inherits(GenericBarcode, _Barcode);
function GenericBarcode(data, options) {
_classCallCheck(this, GenericBarcode);
return _possibleConstructorReturn(this, (GenericBarcode.__proto__ || Object.getPrototypeOf(GenericBarcode)).call(this, data, options)); // Sets this.data and this.text
}
// Return the corresponding binary numbers for the data provided
_createClass(GenericBarcode, [{
key: "encode",
value: function encode() {
return {
data: "10101010101010101010101010101010101010101",
text: this.text
};
}
// Resturn true/false if the string provided is valid for this encoder
}, {
key: "valid",
value: function valid() {
return true;
}
}]);
return GenericBarcode;
}(_Barcode3.default);
exports.GenericBarcode = GenericBarcode;

69
node_modules/jsbarcode/bin/barcodes/ITF/ITF.js generated vendored Executable file
View File

@@ -0,0 +1,69 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _constants = require('./constants');
var _Barcode2 = require('../Barcode');
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ITF = function (_Barcode) {
_inherits(ITF, _Barcode);
function ITF() {
_classCallCheck(this, ITF);
return _possibleConstructorReturn(this, (ITF.__proto__ || Object.getPrototypeOf(ITF)).apply(this, arguments));
}
_createClass(ITF, [{
key: 'valid',
value: function valid() {
return this.data.search(/^([0-9]{2})+$/) !== -1;
}
}, {
key: 'encode',
value: function encode() {
var _this2 = this;
// Calculate all the digit pairs
var encoded = this.data.match(/.{2}/g).map(function (pair) {
return _this2.encodePair(pair);
}).join('');
return {
data: _constants.START_BIN + encoded + _constants.END_BIN,
text: this.text
};
}
// Calculate the data of a number pair
}, {
key: 'encodePair',
value: function encodePair(pair) {
var second = _constants.BINARIES[pair[1]];
return _constants.BINARIES[pair[0]].split('').map(function (first, idx) {
return (first === '1' ? '111' : '1') + (second[idx] === '1' ? '000' : '0');
}).join('');
}
}]);
return ITF;
}(_Barcode3.default);
exports.default = ITF;

55
node_modules/jsbarcode/bin/barcodes/ITF/ITF14.js generated vendored Executable file
View File

@@ -0,0 +1,55 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _ITF2 = require('./ITF');
var _ITF3 = _interopRequireDefault(_ITF2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
// Calculate the checksum digit
var checksum = function checksum(data) {
var res = data.substr(0, 13).split('').map(function (num) {
return parseInt(num, 10);
}).reduce(function (sum, n, idx) {
return sum + n * (3 - idx % 2 * 2);
}, 0);
return Math.ceil(res / 10) * 10 - res;
};
var ITF14 = function (_ITF) {
_inherits(ITF14, _ITF);
function ITF14(data, options) {
_classCallCheck(this, ITF14);
// Add checksum if it does not exist
if (data.search(/^[0-9]{13}$/) !== -1) {
data += checksum(data);
}
return _possibleConstructorReturn(this, (ITF14.__proto__ || Object.getPrototypeOf(ITF14)).call(this, data, options));
}
_createClass(ITF14, [{
key: 'valid',
value: function valid() {
return this.data.search(/^[0-9]{14}$/) !== -1 && +this.data[13] === checksum(this.data);
}
}]);
return ITF14;
}(_ITF3.default);
exports.default = ITF14;

9
node_modules/jsbarcode/bin/barcodes/ITF/constants.js generated vendored Executable file
View File

@@ -0,0 +1,9 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var START_BIN = exports.START_BIN = '1010';
var END_BIN = exports.END_BIN = '11101';
var BINARIES = exports.BINARIES = ['00110', '10001', '01001', '11000', '00101', '10100', '01100', '00011', '10010', '01010'];

19
node_modules/jsbarcode/bin/barcodes/ITF/index.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ITF14 = exports.ITF = undefined;
var _ITF = require('./ITF');
var _ITF2 = _interopRequireDefault(_ITF);
var _ITF3 = require('./ITF14');
var _ITF4 = _interopRequireDefault(_ITF3);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.ITF = _ITF2.default;
exports.ITF14 = _ITF4.default;

74
node_modules/jsbarcode/bin/barcodes/MSI/MSI.js generated vendored Executable file
View File

@@ -0,0 +1,74 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation
// https://en.wikipedia.org/wiki/MSI_Barcode#Character_set_and_binary_lookup
var MSI = function (_Barcode) {
_inherits(MSI, _Barcode);
function MSI(data, options) {
_classCallCheck(this, MSI);
return _possibleConstructorReturn(this, (MSI.__proto__ || Object.getPrototypeOf(MSI)).call(this, data, options));
}
_createClass(MSI, [{
key: "encode",
value: function encode() {
// Start bits
var ret = "110";
for (var i = 0; i < this.data.length; i++) {
// Convert the character to binary (always 4 binary digits)
var digit = parseInt(this.data[i]);
var bin = digit.toString(2);
bin = addZeroes(bin, 4 - bin.length);
// Add 100 for every zero and 110 for every 1
for (var b = 0; b < bin.length; b++) {
ret += bin[b] == "0" ? "100" : "110";
}
}
// End bits
ret += "1001";
return {
data: ret,
text: this.text
};
}
}, {
key: "valid",
value: function valid() {
return this.data.search(/^[0-9]+$/) !== -1;
}
}]);
return MSI;
}(_Barcode3.default);
function addZeroes(number, n) {
for (var i = 0; i < n; i++) {
number = "0" + number;
}
return number;
}
exports.default = MSI;

33
node_modules/jsbarcode/bin/barcodes/MSI/MSI10.js generated vendored Executable file
View File

@@ -0,0 +1,33 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _MSI2 = require('./MSI.js');
var _MSI3 = _interopRequireDefault(_MSI2);
var _checksums = require('./checksums.js');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var MSI10 = function (_MSI) {
_inherits(MSI10, _MSI);
function MSI10(data, options) {
_classCallCheck(this, MSI10);
return _possibleConstructorReturn(this, (MSI10.__proto__ || Object.getPrototypeOf(MSI10)).call(this, data + (0, _checksums.mod10)(data), options));
}
return MSI10;
}(_MSI3.default);
exports.default = MSI10;

35
node_modules/jsbarcode/bin/barcodes/MSI/MSI1010.js generated vendored Executable file
View File

@@ -0,0 +1,35 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _MSI2 = require('./MSI.js');
var _MSI3 = _interopRequireDefault(_MSI2);
var _checksums = require('./checksums.js');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var MSI1010 = function (_MSI) {
_inherits(MSI1010, _MSI);
function MSI1010(data, options) {
_classCallCheck(this, MSI1010);
data += (0, _checksums.mod10)(data);
data += (0, _checksums.mod10)(data);
return _possibleConstructorReturn(this, (MSI1010.__proto__ || Object.getPrototypeOf(MSI1010)).call(this, data, options));
}
return MSI1010;
}(_MSI3.default);
exports.default = MSI1010;

33
node_modules/jsbarcode/bin/barcodes/MSI/MSI11.js generated vendored Executable file
View File

@@ -0,0 +1,33 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _MSI2 = require('./MSI.js');
var _MSI3 = _interopRequireDefault(_MSI2);
var _checksums = require('./checksums.js');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var MSI11 = function (_MSI) {
_inherits(MSI11, _MSI);
function MSI11(data, options) {
_classCallCheck(this, MSI11);
return _possibleConstructorReturn(this, (MSI11.__proto__ || Object.getPrototypeOf(MSI11)).call(this, data + (0, _checksums.mod11)(data), options));
}
return MSI11;
}(_MSI3.default);
exports.default = MSI11;

35
node_modules/jsbarcode/bin/barcodes/MSI/MSI1110.js generated vendored Executable file
View File

@@ -0,0 +1,35 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _MSI2 = require('./MSI.js');
var _MSI3 = _interopRequireDefault(_MSI2);
var _checksums = require('./checksums.js');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var MSI1110 = function (_MSI) {
_inherits(MSI1110, _MSI);
function MSI1110(data, options) {
_classCallCheck(this, MSI1110);
data += (0, _checksums.mod11)(data);
data += (0, _checksums.mod10)(data);
return _possibleConstructorReturn(this, (MSI1110.__proto__ || Object.getPrototypeOf(MSI1110)).call(this, data, options));
}
return MSI1110;
}(_MSI3.default);
exports.default = MSI1110;

29
node_modules/jsbarcode/bin/barcodes/MSI/checksums.js generated vendored Executable file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.mod10 = mod10;
exports.mod11 = mod11;
function mod10(number) {
var sum = 0;
for (var i = 0; i < number.length; i++) {
var n = parseInt(number[i]);
if ((i + number.length) % 2 === 0) {
sum += n;
} else {
sum += n * 2 % 10 + Math.floor(n * 2 / 10);
}
}
return (10 - sum % 10) % 10;
}
function mod11(number) {
var sum = 0;
var weights = [2, 3, 4, 5, 6, 7];
for (var i = 0; i < number.length; i++) {
var n = parseInt(number[number.length - 1 - i]);
sum += weights[i % weights.length] * n;
}
return (11 - sum % 11) % 11;
}

34
node_modules/jsbarcode/bin/barcodes/MSI/index.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.MSI1110 = exports.MSI1010 = exports.MSI11 = exports.MSI10 = exports.MSI = undefined;
var _MSI = require('./MSI.js');
var _MSI2 = _interopRequireDefault(_MSI);
var _MSI3 = require('./MSI10.js');
var _MSI4 = _interopRequireDefault(_MSI3);
var _MSI5 = require('./MSI11.js');
var _MSI6 = _interopRequireDefault(_MSI5);
var _MSI7 = require('./MSI1010.js');
var _MSI8 = _interopRequireDefault(_MSI7);
var _MSI9 = require('./MSI1110.js');
var _MSI10 = _interopRequireDefault(_MSI9);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.MSI = _MSI2.default;
exports.MSI10 = _MSI4.default;
exports.MSI11 = _MSI6.default;
exports.MSI1010 = _MSI8.default;
exports.MSI1110 = _MSI10.default;

92
node_modules/jsbarcode/bin/barcodes/codabar/index.js generated vendored Normal file
View File

@@ -0,0 +1,92 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.codabar = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding specification:
// http://www.barcodeisland.com/codabar.phtml
var codabar = function (_Barcode) {
_inherits(codabar, _Barcode);
function codabar(data, options) {
_classCallCheck(this, codabar);
if (data.search(/^[0-9\-\$\:\.\+\/]+$/) === 0) {
data = "A" + data + "A";
}
var _this = _possibleConstructorReturn(this, (codabar.__proto__ || Object.getPrototypeOf(codabar)).call(this, data.toUpperCase(), options));
_this.text = _this.options.text || _this.text.replace(/[A-D]/g, '');
return _this;
}
_createClass(codabar, [{
key: "valid",
value: function valid() {
return this.data.search(/^[A-D][0-9\-\$\:\.\+\/]+[A-D]$/) !== -1;
}
}, {
key: "encode",
value: function encode() {
var result = [];
var encodings = this.getEncodings();
for (var i = 0; i < this.data.length; i++) {
result.push(encodings[this.data.charAt(i)]);
// for all characters except the last, append a narrow-space ("0")
if (i !== this.data.length - 1) {
result.push("0");
}
}
return {
text: this.text,
data: result.join('')
};
}
}, {
key: "getEncodings",
value: function getEncodings() {
return {
"0": "101010011",
"1": "101011001",
"2": "101001011",
"3": "110010101",
"4": "101101001",
"5": "110101001",
"6": "100101011",
"7": "100101101",
"8": "100110101",
"9": "110100101",
"-": "101001101",
"$": "101100101",
":": "1101011011",
"/": "1101101011",
".": "1101101101",
"+": "1011011011",
"A": "1011001001",
"B": "1001001011",
"C": "1010010011",
"D": "1010011001"
};
}
}]);
return codabar;
}(_Barcode3.default);
exports.codabar = codabar;

33
node_modules/jsbarcode/bin/barcodes/index.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _CODE = require('./CODE39/');
var _CODE2 = require('./CODE128/');
var _EAN_UPC = require('./EAN_UPC/');
var _ITF = require('./ITF/');
var _MSI = require('./MSI/');
var _pharmacode = require('./pharmacode/');
var _codabar = require('./codabar');
var _GenericBarcode = require('./GenericBarcode/');
exports.default = {
CODE39: _CODE.CODE39,
CODE128: _CODE2.CODE128, CODE128A: _CODE2.CODE128A, CODE128B: _CODE2.CODE128B, CODE128C: _CODE2.CODE128C,
EAN13: _EAN_UPC.EAN13, EAN8: _EAN_UPC.EAN8, EAN5: _EAN_UPC.EAN5, EAN2: _EAN_UPC.EAN2, UPC: _EAN_UPC.UPC, UPCE: _EAN_UPC.UPCE,
ITF14: _ITF.ITF14,
ITF: _ITF.ITF,
MSI: _MSI.MSI, MSI10: _MSI.MSI10, MSI11: _MSI.MSI11, MSI1010: _MSI.MSI1010, MSI1110: _MSI.MSI1110,
pharmacode: _pharmacode.pharmacode,
codabar: _codabar.codabar,
GenericBarcode: _GenericBarcode.GenericBarcode
};

33
node_modules/jsbarcode/bin/barcodes/index.tmp.js generated vendored Executable file
View File

@@ -0,0 +1,33 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _CODE = require('./CODE39/');
var _CODE2 = require('./CODE128/');
var _EAN_UPC = require('./EAN_UPC/');
var _ITF = require('./ITF/');
var _MSI = require('./MSI/');
var _pharmacode = require('./pharmacode/');
var _codabar = require('./codabar');
var _GenericBarcode = require('./GenericBarcode/');
exports.default = {
CODE39: _CODE.CODE39,
CODE128: _CODE2.CODE128, CODE128A: _CODE2.CODE128A, CODE128B: _CODE2.CODE128B, CODE128C: _CODE2.CODE128C,
EAN13: _EAN_UPC.EAN13, EAN8: _EAN_UPC.EAN8, EAN5: _EAN_UPC.EAN5, EAN2: _EAN_UPC.EAN2, UPC: _EAN_UPC.UPC, UPCE: _EAN_UPC.UPCE,
ITF14: _ITF.ITF14,
ITF: _ITF.ITF,
MSI: _MSI.MSI, MSI10: _MSI.MSI10, MSI11: _MSI.MSI11, MSI1010: _MSI.MSI1010, MSI1110: _MSI.MSI1110,
pharmacode: _pharmacode.pharmacode,
codabar: _codabar.codabar,
GenericBarcode: _GenericBarcode.GenericBarcode
};

View File

@@ -0,0 +1,73 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.pharmacode = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _Barcode2 = require("../Barcode.js");
var _Barcode3 = _interopRequireDefault(_Barcode2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Encoding documentation
// http://www.gomaro.ch/ftproot/Laetus_PHARMA-CODE.pdf
var pharmacode = function (_Barcode) {
_inherits(pharmacode, _Barcode);
function pharmacode(data, options) {
_classCallCheck(this, pharmacode);
var _this = _possibleConstructorReturn(this, (pharmacode.__proto__ || Object.getPrototypeOf(pharmacode)).call(this, data, options));
_this.number = parseInt(data, 10);
return _this;
}
_createClass(pharmacode, [{
key: "encode",
value: function encode() {
var z = this.number;
var result = "";
// http://i.imgur.com/RMm4UDJ.png
// (source: http://www.gomaro.ch/ftproot/Laetus_PHARMA-CODE.pdf, page: 34)
while (!isNaN(z) && z != 0) {
if (z % 2 === 0) {
// Even
result = "11100" + result;
z = (z - 2) / 2;
} else {
// Odd
result = "100" + result;
z = (z - 1) / 2;
}
}
// Remove the two last zeroes
result = result.slice(0, -2);
return {
data: result,
text: this.text
};
}
}, {
key: "valid",
value: function valid() {
return this.number >= 3 && this.number <= 131070;
}
}]);
return pharmacode;
}(_Barcode3.default);
exports.pharmacode = pharmacode;

54
node_modules/jsbarcode/bin/exceptions/ErrorHandler.js generated vendored Executable file
View File

@@ -0,0 +1,54 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/*eslint no-console: 0 */
var ErrorHandler = function () {
function ErrorHandler(api) {
_classCallCheck(this, ErrorHandler);
this.api = api;
}
_createClass(ErrorHandler, [{
key: "handleCatch",
value: function handleCatch(e) {
// If babel supported extending of Error in a correct way instanceof would be used here
if (e.name === "InvalidInputException") {
if (this.api._options.valid !== this.api._defaults.valid) {
this.api._options.valid(false);
} else {
throw e.message;
}
} else {
throw e;
}
this.api.render = function () {};
}
}, {
key: "wrapBarcodeCall",
value: function wrapBarcodeCall(func) {
try {
var result = func.apply(undefined, arguments);
this.api._options.valid(true);
return result;
} catch (e) {
this.handleCatch(e);
return this.api;
}
}
}]);
return ErrorHandler;
}();
exports.default = ErrorHandler;

67
node_modules/jsbarcode/bin/exceptions/exceptions.js generated vendored Executable file
View File

@@ -0,0 +1,67 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var InvalidInputException = function (_Error) {
_inherits(InvalidInputException, _Error);
function InvalidInputException(symbology, input) {
_classCallCheck(this, InvalidInputException);
var _this = _possibleConstructorReturn(this, (InvalidInputException.__proto__ || Object.getPrototypeOf(InvalidInputException)).call(this));
_this.name = "InvalidInputException";
_this.symbology = symbology;
_this.input = input;
_this.message = '"' + _this.input + '" is not a valid input for ' + _this.symbology;
return _this;
}
return InvalidInputException;
}(Error);
var InvalidElementException = function (_Error2) {
_inherits(InvalidElementException, _Error2);
function InvalidElementException() {
_classCallCheck(this, InvalidElementException);
var _this2 = _possibleConstructorReturn(this, (InvalidElementException.__proto__ || Object.getPrototypeOf(InvalidElementException)).call(this));
_this2.name = "InvalidElementException";
_this2.message = "Not supported type to render on";
return _this2;
}
return InvalidElementException;
}(Error);
var NoElementException = function (_Error3) {
_inherits(NoElementException, _Error3);
function NoElementException() {
_classCallCheck(this, NoElementException);
var _this3 = _possibleConstructorReturn(this, (NoElementException.__proto__ || Object.getPrototypeOf(NoElementException)).call(this));
_this3.name = "NoElementException";
_this3.message = "No element to render on.";
return _this3;
}
return NoElementException;
}(Error);
exports.InvalidInputException = InvalidInputException;
exports.InvalidElementException = InvalidElementException;
exports.NoElementException = NoElementException;

17
node_modules/jsbarcode/bin/help/fixOptions.js generated vendored Executable file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = fixOptions;
function fixOptions(options) {
// Fix the margins
options.marginTop = options.marginTop || options.margin;
options.marginBottom = options.marginBottom || options.margin;
options.marginRight = options.marginRight || options.margin;
options.marginLeft = options.marginLeft || options.margin;
return options;
}

41
node_modules/jsbarcode/bin/help/getOptionsFromElement.js generated vendored Executable file
View File

@@ -0,0 +1,41 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _optionsFromStrings = require("./optionsFromStrings.js");
var _optionsFromStrings2 = _interopRequireDefault(_optionsFromStrings);
var _defaults = require("../options/defaults.js");
var _defaults2 = _interopRequireDefault(_defaults);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function getOptionsFromElement(element) {
var options = {};
for (var property in _defaults2.default) {
if (_defaults2.default.hasOwnProperty(property)) {
// jsbarcode-*
if (element.hasAttribute("jsbarcode-" + property.toLowerCase())) {
options[property] = element.getAttribute("jsbarcode-" + property.toLowerCase());
}
// data-*
if (element.hasAttribute("data-" + property.toLowerCase())) {
options[property] = element.getAttribute("data-" + property.toLowerCase());
}
}
}
options["value"] = element.getAttribute("jsbarcode-value") || element.getAttribute("data-value");
// Since all atributes are string they need to be converted to integers
options = (0, _optionsFromStrings2.default)(options);
return options;
}
exports.default = getOptionsFromElement;

108
node_modules/jsbarcode/bin/help/getRenderProperties.js generated vendored Executable file
View File

@@ -0,0 +1,108 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; /* global HTMLImageElement */
/* global HTMLCanvasElement */
/* global SVGElement */
var _getOptionsFromElement = require("./getOptionsFromElement.js");
var _getOptionsFromElement2 = _interopRequireDefault(_getOptionsFromElement);
var _renderers = require("../renderers");
var _renderers2 = _interopRequireDefault(_renderers);
var _exceptions = require("../exceptions/exceptions.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// Takes an element and returns an object with information about how
// it should be rendered
// This could also return an array with these objects
// {
// element: The element that the renderer should draw on
// renderer: The name of the renderer
// afterRender (optional): If something has to done after the renderer
// completed, calls afterRender (function)
// options (optional): Options that can be defined in the element
// }
function getRenderProperties(element) {
// If the element is a string, query select call again
if (typeof element === "string") {
return querySelectedRenderProperties(element);
}
// If element is array. Recursivly call with every object in the array
else if (Array.isArray(element)) {
var returnArray = [];
for (var i = 0; i < element.length; i++) {
returnArray.push(getRenderProperties(element[i]));
}
return returnArray;
}
// If element, render on canvas and set the uri as src
else if (typeof HTMLCanvasElement !== 'undefined' && element instanceof HTMLImageElement) {
return newCanvasRenderProperties(element);
}
// If SVG
else if (element && element.nodeName && element.nodeName.toLowerCase() === 'svg' || typeof SVGElement !== 'undefined' && element instanceof SVGElement) {
return {
element: element,
options: (0, _getOptionsFromElement2.default)(element),
renderer: _renderers2.default.SVGRenderer
};
}
// If canvas (in browser)
else if (typeof HTMLCanvasElement !== 'undefined' && element instanceof HTMLCanvasElement) {
return {
element: element,
options: (0, _getOptionsFromElement2.default)(element),
renderer: _renderers2.default.CanvasRenderer
};
}
// If canvas (in node)
else if (element && element.getContext) {
return {
element: element,
renderer: _renderers2.default.CanvasRenderer
};
} else if (element && (typeof element === "undefined" ? "undefined" : _typeof(element)) === 'object' && !element.nodeName) {
return {
element: element,
renderer: _renderers2.default.ObjectRenderer
};
} else {
throw new _exceptions.InvalidElementException();
}
}
function querySelectedRenderProperties(string) {
var selector = document.querySelectorAll(string);
if (selector.length === 0) {
return undefined;
} else {
var returnArray = [];
for (var i = 0; i < selector.length; i++) {
returnArray.push(getRenderProperties(selector[i]));
}
return returnArray;
}
}
function newCanvasRenderProperties(imgElement) {
var canvas = document.createElement('canvas');
return {
element: canvas,
options: (0, _getOptionsFromElement2.default)(imgElement),
renderer: _renderers2.default.CanvasRenderer,
afterRender: function afterRender() {
imgElement.setAttribute("src", canvas.toDataURL());
}
};
}
exports.default = getRenderProperties;

27
node_modules/jsbarcode/bin/help/linearizeEncodings.js generated vendored Executable file
View File

@@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = linearizeEncodings;
// Encodings can be nestled like [[1-1, 1-2], 2, [3-1, 3-2]
// Convert to [1-1, 1-2, 2, 3-1, 3-2]
function linearizeEncodings(encodings) {
var linearEncodings = [];
function nextLevel(encoded) {
if (Array.isArray(encoded)) {
for (var i = 0; i < encoded.length; i++) {
nextLevel(encoded[i]);
}
} else {
encoded.text = encoded.text || "";
encoded.data = encoded.data || "";
linearEncodings.push(encoded);
}
}
nextLevel(encodings);
return linearEncodings;
}

11
node_modules/jsbarcode/bin/help/merge.js generated vendored Executable file
View File

@@ -0,0 +1,11 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
exports.default = function (old, replaceObj) {
return _extends({}, old, replaceObj);
};

27
node_modules/jsbarcode/bin/help/optionsFromStrings.js generated vendored Executable file
View File

@@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = optionsFromStrings;
// Convert string to integers/booleans where it should be
function optionsFromStrings(options) {
var intOptions = ["width", "height", "textMargin", "fontSize", "margin", "marginTop", "marginBottom", "marginLeft", "marginRight"];
for (var intOption in intOptions) {
if (intOptions.hasOwnProperty(intOption)) {
intOption = intOptions[intOption];
if (typeof options[intOption] === "string") {
options[intOption] = parseInt(options[intOption], 10);
}
}
}
if (typeof options["displayValue"] === "string") {
options["displayValue"] = options["displayValue"] != "false";
}
return options;
}

28
node_modules/jsbarcode/bin/options/defaults.js generated vendored Executable file
View File

@@ -0,0 +1,28 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var defaults = {
width: 2,
height: 100,
format: "auto",
displayValue: true,
fontOptions: "",
font: "monospace",
text: undefined,
textAlign: "center",
textPosition: "bottom",
textMargin: 2,
fontSize: 20,
background: "#ffffff",
lineColor: "#000000",
margin: 10,
marginTop: undefined,
marginBottom: undefined,
marginLeft: undefined,
marginRight: undefined,
valid: function valid() {}
};
exports.default = defaults;

158
node_modules/jsbarcode/bin/renderers/canvas.js generated vendored Executable file
View File

@@ -0,0 +1,158 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _merge = require("../help/merge.js");
var _merge2 = _interopRequireDefault(_merge);
var _shared = require("./shared.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var CanvasRenderer = function () {
function CanvasRenderer(canvas, encodings, options) {
_classCallCheck(this, CanvasRenderer);
this.canvas = canvas;
this.encodings = encodings;
this.options = options;
}
_createClass(CanvasRenderer, [{
key: "render",
value: function render() {
// Abort if the browser does not support HTML5 canvas
if (!this.canvas.getContext) {
throw new Error('The browser does not support canvas.');
}
this.prepareCanvas();
for (var i = 0; i < this.encodings.length; i++) {
var encodingOptions = (0, _merge2.default)(this.options, this.encodings[i].options);
this.drawCanvasBarcode(encodingOptions, this.encodings[i]);
this.drawCanvasText(encodingOptions, this.encodings[i]);
this.moveCanvasDrawing(this.encodings[i]);
}
this.restoreCanvas();
}
}, {
key: "prepareCanvas",
value: function prepareCanvas() {
// Get the canvas context
var ctx = this.canvas.getContext("2d");
ctx.save();
(0, _shared.calculateEncodingAttributes)(this.encodings, this.options, ctx);
var totalWidth = (0, _shared.getTotalWidthOfEncodings)(this.encodings);
var maxHeight = (0, _shared.getMaximumHeightOfEncodings)(this.encodings);
this.canvas.width = totalWidth + this.options.marginLeft + this.options.marginRight;
this.canvas.height = maxHeight;
// Paint the canvas
ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
if (this.options.background) {
ctx.fillStyle = this.options.background;
ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
}
ctx.translate(this.options.marginLeft, 0);
}
}, {
key: "drawCanvasBarcode",
value: function drawCanvasBarcode(options, encoding) {
// Get the canvas context
var ctx = this.canvas.getContext("2d");
var binary = encoding.data;
// Creates the barcode out of the encoded binary
var yFrom;
if (options.textPosition == "top") {
yFrom = options.marginTop + options.fontSize + options.textMargin;
} else {
yFrom = options.marginTop;
}
ctx.fillStyle = options.lineColor;
for (var b = 0; b < binary.length; b++) {
var x = b * options.width + encoding.barcodePadding;
if (binary[b] === "1") {
ctx.fillRect(x, yFrom, options.width, options.height);
} else if (binary[b]) {
ctx.fillRect(x, yFrom, options.width, options.height * binary[b]);
}
}
}
}, {
key: "drawCanvasText",
value: function drawCanvasText(options, encoding) {
// Get the canvas context
var ctx = this.canvas.getContext("2d");
var font = options.fontOptions + " " + options.fontSize + "px " + options.font;
// Draw the text if displayValue is set
if (options.displayValue) {
var x, y;
if (options.textPosition == "top") {
y = options.marginTop + options.fontSize - options.textMargin;
} else {
y = options.height + options.textMargin + options.marginTop + options.fontSize;
}
ctx.font = font;
// Draw the text in the correct X depending on the textAlign option
if (options.textAlign == "left" || encoding.barcodePadding > 0) {
x = 0;
ctx.textAlign = 'left';
} else if (options.textAlign == "right") {
x = encoding.width - 1;
ctx.textAlign = 'right';
}
// In all other cases, center the text
else {
x = encoding.width / 2;
ctx.textAlign = 'center';
}
ctx.fillText(encoding.text, x, y);
}
}
}, {
key: "moveCanvasDrawing",
value: function moveCanvasDrawing(encoding) {
var ctx = this.canvas.getContext("2d");
ctx.translate(encoding.width, 0);
}
}, {
key: "restoreCanvas",
value: function restoreCanvas() {
// Get the canvas context
var ctx = this.canvas.getContext("2d");
ctx.restore();
}
}]);
return CanvasRenderer;
}();
exports.default = CanvasRenderer;

21
node_modules/jsbarcode/bin/renderers/index.js generated vendored Executable file
View File

@@ -0,0 +1,21 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _canvas = require('./canvas.js');
var _canvas2 = _interopRequireDefault(_canvas);
var _svg = require('./svg.js');
var _svg2 = _interopRequireDefault(_svg);
var _object = require('./object.js');
var _object2 = _interopRequireDefault(_object);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = { CanvasRenderer: _canvas2.default, SVGRenderer: _svg2.default, ObjectRenderer: _object2.default };

30
node_modules/jsbarcode/bin/renderers/object.js generated vendored Executable file
View File

@@ -0,0 +1,30 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var ObjectRenderer = function () {
function ObjectRenderer(object, encodings, options) {
_classCallCheck(this, ObjectRenderer);
this.object = object;
this.encodings = encodings;
this.options = options;
}
_createClass(ObjectRenderer, [{
key: "render",
value: function render() {
this.object.encodings = this.encodings;
}
}]);
return ObjectRenderer;
}();
exports.default = ObjectRenderer;

101
node_modules/jsbarcode/bin/renderers/shared.js generated vendored Executable file
View File

@@ -0,0 +1,101 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getTotalWidthOfEncodings = exports.calculateEncodingAttributes = exports.getBarcodePadding = exports.getEncodingHeight = exports.getMaximumHeightOfEncodings = undefined;
var _merge = require("../help/merge.js");
var _merge2 = _interopRequireDefault(_merge);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function getEncodingHeight(encoding, options) {
return options.height + (options.displayValue && encoding.text.length > 0 ? options.fontSize + options.textMargin : 0) + options.marginTop + options.marginBottom;
}
function getBarcodePadding(textWidth, barcodeWidth, options) {
if (options.displayValue && barcodeWidth < textWidth) {
if (options.textAlign == "center") {
return Math.floor((textWidth - barcodeWidth) / 2);
} else if (options.textAlign == "left") {
return 0;
} else if (options.textAlign == "right") {
return Math.floor(textWidth - barcodeWidth);
}
}
return 0;
}
function calculateEncodingAttributes(encodings, barcodeOptions, context) {
for (var i = 0; i < encodings.length; i++) {
var encoding = encodings[i];
var options = (0, _merge2.default)(barcodeOptions, encoding.options);
// Calculate the width of the encoding
var textWidth;
if (options.displayValue) {
textWidth = messureText(encoding.text, options, context);
} else {
textWidth = 0;
}
var barcodeWidth = encoding.data.length * options.width;
encoding.width = Math.ceil(Math.max(textWidth, barcodeWidth));
encoding.height = getEncodingHeight(encoding, options);
encoding.barcodePadding = getBarcodePadding(textWidth, barcodeWidth, options);
}
}
function getTotalWidthOfEncodings(encodings) {
var totalWidth = 0;
for (var i = 0; i < encodings.length; i++) {
totalWidth += encodings[i].width;
}
return totalWidth;
}
function getMaximumHeightOfEncodings(encodings) {
var maxHeight = 0;
for (var i = 0; i < encodings.length; i++) {
if (encodings[i].height > maxHeight) {
maxHeight = encodings[i].height;
}
}
return maxHeight;
}
function messureText(string, options, context) {
var ctx;
if (context) {
ctx = context;
} else if (typeof document !== "undefined") {
ctx = document.createElement("canvas").getContext("2d");
} else {
// If the text cannot be messured we will return 0.
// This will make some barcode with big text render incorrectly
return 0;
}
ctx.font = options.fontOptions + " " + options.fontSize + "px " + options.font;
// Calculate the width of the encoding
var measureTextResult = ctx.measureText(string);
if (!measureTextResult) {
// Some implementations don't implement measureText and return undefined.
// If the text cannot be measured we will return 0.
// This will make some barcode with big text render incorrectly
return 0;
}
var size = measureTextResult.width;
return size;
}
exports.getMaximumHeightOfEncodings = getMaximumHeightOfEncodings;
exports.getEncodingHeight = getEncodingHeight;
exports.getBarcodePadding = getBarcodePadding;
exports.calculateEncodingAttributes = calculateEncodingAttributes;
exports.getTotalWidthOfEncodings = getTotalWidthOfEncodings;

189
node_modules/jsbarcode/bin/renderers/svg.js generated vendored Executable file
View File

@@ -0,0 +1,189 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _merge = require("../help/merge.js");
var _merge2 = _interopRequireDefault(_merge);
var _shared = require("./shared.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var svgns = "http://www.w3.org/2000/svg";
var SVGRenderer = function () {
function SVGRenderer(svg, encodings, options) {
_classCallCheck(this, SVGRenderer);
this.svg = svg;
this.encodings = encodings;
this.options = options;
this.document = options.xmlDocument || document;
}
_createClass(SVGRenderer, [{
key: "render",
value: function render() {
var currentX = this.options.marginLeft;
this.prepareSVG();
for (var i = 0; i < this.encodings.length; i++) {
var encoding = this.encodings[i];
var encodingOptions = (0, _merge2.default)(this.options, encoding.options);
var group = this.createGroup(currentX, encodingOptions.marginTop, this.svg);
this.setGroupOptions(group, encodingOptions);
this.drawSvgBarcode(group, encodingOptions, encoding);
this.drawSVGText(group, encodingOptions, encoding);
currentX += encoding.width;
}
}
}, {
key: "prepareSVG",
value: function prepareSVG() {
// Clear the SVG
while (this.svg.firstChild) {
this.svg.removeChild(this.svg.firstChild);
}
(0, _shared.calculateEncodingAttributes)(this.encodings, this.options);
var totalWidth = (0, _shared.getTotalWidthOfEncodings)(this.encodings);
var maxHeight = (0, _shared.getMaximumHeightOfEncodings)(this.encodings);
var width = totalWidth + this.options.marginLeft + this.options.marginRight;
this.setSvgAttributes(width, maxHeight);
if (this.options.background) {
this.drawRect(0, 0, width, maxHeight, this.svg).setAttribute("style", "fill:" + this.options.background + ";");
}
}
}, {
key: "drawSvgBarcode",
value: function drawSvgBarcode(parent, options, encoding) {
var binary = encoding.data;
// Creates the barcode out of the encoded binary
var yFrom;
if (options.textPosition == "top") {
yFrom = options.fontSize + options.textMargin;
} else {
yFrom = 0;
}
var barWidth = 0;
var x = 0;
for (var b = 0; b < binary.length; b++) {
x = b * options.width + encoding.barcodePadding;
if (binary[b] === "1") {
barWidth++;
} else if (barWidth > 0) {
this.drawRect(x - options.width * barWidth, yFrom, options.width * barWidth, options.height, parent);
barWidth = 0;
}
}
// Last draw is needed since the barcode ends with 1
if (barWidth > 0) {
this.drawRect(x - options.width * (barWidth - 1), yFrom, options.width * barWidth, options.height, parent);
}
}
}, {
key: "drawSVGText",
value: function drawSVGText(parent, options, encoding) {
var textElem = this.document.createElementNS(svgns, 'text');
// Draw the text if displayValue is set
if (options.displayValue) {
var x, y;
textElem.setAttribute("style", "font:" + options.fontOptions + " " + options.fontSize + "px " + options.font);
if (options.textPosition == "top") {
y = options.fontSize - options.textMargin;
} else {
y = options.height + options.textMargin + options.fontSize;
}
// Draw the text in the correct X depending on the textAlign option
if (options.textAlign == "left" || encoding.barcodePadding > 0) {
x = 0;
textElem.setAttribute("text-anchor", "start");
} else if (options.textAlign == "right") {
x = encoding.width - 1;
textElem.setAttribute("text-anchor", "end");
}
// In all other cases, center the text
else {
x = encoding.width / 2;
textElem.setAttribute("text-anchor", "middle");
}
textElem.setAttribute("x", x);
textElem.setAttribute("y", y);
textElem.appendChild(this.document.createTextNode(encoding.text));
parent.appendChild(textElem);
}
}
}, {
key: "setSvgAttributes",
value: function setSvgAttributes(width, height) {
var svg = this.svg;
svg.setAttribute("width", width + "px");
svg.setAttribute("height", height + "px");
svg.setAttribute("x", "0px");
svg.setAttribute("y", "0px");
svg.setAttribute("viewBox", "0 0 " + width + " " + height);
svg.setAttribute("xmlns", svgns);
svg.setAttribute("version", "1.1");
svg.setAttribute("style", "transform: translate(0,0)");
}
}, {
key: "createGroup",
value: function createGroup(x, y, parent) {
var group = this.document.createElementNS(svgns, 'g');
group.setAttribute("transform", "translate(" + x + ", " + y + ")");
parent.appendChild(group);
return group;
}
}, {
key: "setGroupOptions",
value: function setGroupOptions(group, options) {
group.setAttribute("style", "fill:" + options.lineColor + ";");
}
}, {
key: "drawRect",
value: function drawRect(x, y, width, height, parent) {
var rect = this.document.createElementNS(svgns, 'rect');
rect.setAttribute("x", x);
rect.setAttribute("y", y);
rect.setAttribute("width", width);
rect.setAttribute("height", height);
parent.appendChild(rect);
return rect;
}
}]);
return SVGRenderer;
}();
exports.default = SVGRenderer;

35
node_modules/jsbarcode/bower.json generated vendored Normal file
View File

@@ -0,0 +1,35 @@
{
"name": "JsBarcode",
"main": "dist/JsBarcode.all.min.js",
"version": "3.11.5",
"homepage": "https://github.com/lindell/JsBarcode",
"authors": [
"Johan Lindell <johan@lindell.me>"
],
"description": "JsBarcode is a simple way to create different types of 1d barcodes.",
"repository": {
"type": "git",
"url": "git://github.com/lindell/JsBarcode"
},
"moduleType": [
"globals"
],
"keywords": [
"barcode",
"canvas",
"code128",
"upc",
"ean",
"itf",
"msi",
"pharmacode"
],
"license": "MIT",
"ignore": [
"**/.*",
"node_modules",
"bower_components",
"test",
"tests"
]
}

3670
node_modules/jsbarcode/dist/JsBarcode.all.js generated vendored Normal file

File diff suppressed because it is too large Load Diff

2
node_modules/jsbarcode/dist/JsBarcode.all.min.js generated vendored Normal file

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

10
node_modules/jsbarcode/docker-compose.yml generated vendored Normal file
View File

@@ -0,0 +1,10 @@
version: '2'
services:
jsbarcode:
build:
context: ./
volumes:
- ./src:/jsbarcode/src
- ./test:/jsbarcode/test
ports:
- 3000:3000

68
node_modules/jsbarcode/example/index.html generated vendored Normal file
View File

@@ -0,0 +1,68 @@
<!DOCTYPE HTML>
<html lang="en-US">
<head>
<meta charset="UTF-8">
<title></title>
<script src="../dist/JsBarcode.all.js"></script>
<script>
Number.prototype.zeroPadding = function(){
var ret = "" + this.valueOf();
return ret.length == 1 ? "0" + ret : ret;
};
</script>
</head>
<body>
<div>
<img id="barcode1"/>
<script>JsBarcode("#barcode1", "Hi!");</script>
</div>
<div>
<img id="barcode2"/>
<script>
JsBarcode("#barcode2", "9780199532179", {
format:"EAN13",
displayValue:true,
fontSize:24,
lineColor: "#0cc"
});
</script>
</div>
<div>
<img id="barcode3"/>
<script>JsBarcode("#barcode3", "9780199532179", {
format:"EAN13",
displayValue:true,
fontSize:20
});</script>
</div>
<div>
<img id="barcode4"/>
<script>
var repeat4 = function(){
var date = new Date();
JsBarcode("#barcode4",
date.getHours().zeroPadding() + ":" +
date.getMinutes().zeroPadding() + ":" +
date.getSeconds().zeroPadding(),
{displayValue: true});
};
setInterval(repeat4,1000);
repeat4();
</script>
</div>
<div>
<img id="barcode5"/>
<script>
var repeat5 = function(){
JsBarcode("#barcode5", Math.floor(1000000+Math.random()*9000000)+"",{displayValue:true,fontSize:20});
};
setInterval(repeat5,500);
repeat5();
</script>
</div>
</body>
</html>

21
node_modules/jsbarcode/example/toBase64.html generated vendored Normal file
View File

@@ -0,0 +1,21 @@
<!DOCTYPE HTML>
<html lang="en-US">
<head>
<meta charset="UTF-8">
<title></title>
<script src="../dist/JsBarcode.all.js"></script>
<script>
function textToBase64Barcode(text){
var canvas = document.createElement("canvas");
JsBarcode(canvas, text, {format: "CODE39"});
return canvas.toDataURL("image/png");
}
</script>
</head>
<body>
<a id="hello">Click Here</a>
<script>
document.querySelector("#hello").href = textToBase64Barcode("HELLO");
</script>
</body>
</html>

19
node_modules/jsbarcode/gulpfile.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
/*eslint
no-console: 0
*/
var gulp = require('gulp');
require('./automation/building.js');
require('./automation/linting.js');
require('./automation/releasing.js');
require('./automation/misc.js');
gulp.task('watch', gulp.series(['compile'], function () {
gulp.watch("src/**/*", ['compile']);
}));
gulp.task('watch-web', gulp.series(['webpack'], function () {
gulp.watch("src/**/*", ['webpack']);
}));

74
node_modules/jsbarcode/jsbarcode.d.ts generated vendored Normal file
View File

@@ -0,0 +1,74 @@
declare namespace JsBarcode {
interface BaseOptions {
width?: number;
height?: number;
format?: string;
displayValue?: boolean;
fontOptions?: string;
font?: string;
text?: string;
textAlign?: string;
textPosition?: string;
textMargin?: number;
fontSize?: number;
background?: string;
lineColor?: string;
margin?: number;
marginTop?: number;
marginBottom?: number;
marginLeft?: number;
marginRight?: number;
valid?: (valid: boolean) => void;
}
interface NodeOptions extends BaseOptions {
xmlDocument?: XMLDocument;
}
interface Code128Options extends BaseOptions {
ean128?: boolean;
}
interface Ean8Options extends BaseOptions {
flat?: boolean;
}
interface Ean13Options extends BaseOptions {
flat?: boolean;
lastChar?: string;
}
type Options = BaseOptions | Code128Options | Ean13Options | NodeOptions;
interface api {
options(options: Options): api;
blank(size: number): api;
init(options?: Options): void;
render(): void;
CODE39(value: string, options?: BaseOptions): api;
CODE128(value: string, options?: Code128Options): api;
CODE128A(value: string, options?: Code128Options): api;
CODE128B(value: string, options?: Code128Options): api;
CODE128C(value: string, options?: Code128Options): api;
EAN13(value: string, options?: Ean13Options): api;
EAN8(value: string, options?: Ean8Options): api;
EAN5(value: string, options?: BaseOptions): api;
EAN2(value: string, options?: BaseOptions): api;
UPC(value: string, options?: BaseOptions): api;
ITF14(value: string, options?: BaseOptions): api;
ITF(value: string, options?: BaseOptions): api;
MSI(value: string, options?: BaseOptions): api;
MSI10(value: string, options?: BaseOptions): api;
MSI11(value: string, options?: BaseOptions): api;
MSI1010(value: string, options?: BaseOptions): api;
MSI1110(value: string, options?: BaseOptions): api;
pharmacode(value: string, options?: BaseOptions): api;
codabar(value: string, options?: BaseOptions): api;
}
}
declare function JsBarcode(element: any): JsBarcode.api;
declare function JsBarcode(element: any, data: string, options?: JsBarcode.Options): void;
export = JsBarcode;
export as namespace JsBarcode;

163
node_modules/jsbarcode/package.json generated vendored Normal file
View File

@@ -0,0 +1,163 @@
{
"_from": "jsbarcode",
"_id": "jsbarcode@3.11.5",
"_inBundle": false,
"_integrity": "sha512-zv3KsH51zD00I/LrFzFSM6dst7rDn0vIMzaiZFL7qusTjPZiPtxg3zxetp0RR7obmjTw4f6NyGgbdkBCgZUIrA==",
"_location": "/jsbarcode",
"_phantomChildren": {},
"_requested": {
"type": "tag",
"registry": true,
"raw": "jsbarcode",
"name": "jsbarcode",
"escapedName": "jsbarcode",
"rawSpec": "",
"saveSpec": null,
"fetchSpec": "latest"
},
"_requiredBy": [
"#USER",
"/"
],
"_resolved": "https://registry.npmjs.org/jsbarcode/-/jsbarcode-3.11.5.tgz",
"_shasum": "390b3efd0271f35b9d68c7b8af6e972445969014",
"_spec": "jsbarcode",
"_where": "/home/frappe/frappe-bench/apps/label_printing",
"author": {
"name": "Johan Lindell"
},
"bin": {
"barcodes": "bin/barcodes",
"Barcode.js": "bin/barcodes/Barcode.js",
"codabar": "bin/barcodes/codabar",
"index.js": "bin/renderers/index.js",
"CODE128": "bin/barcodes/CODE128",
"auto.js": "bin/barcodes/CODE128/auto.js",
"CODE128_AUTO.js": "bin/barcodes/CODE128/CODE128_AUTO.js",
"CODE128.js": "bin/barcodes/CODE128/CODE128.js",
"CODE128A.js": "bin/barcodes/CODE128/CODE128A.js",
"CODE128B.js": "bin/barcodes/CODE128/CODE128B.js",
"CODE128C.js": "bin/barcodes/CODE128/CODE128C.js",
"constants.js": "bin/barcodes/ITF/constants.js",
"CODE39": "bin/barcodes/CODE39",
"EAN_UPC": "bin/barcodes/EAN_UPC",
"EAN.js": "bin/barcodes/EAN_UPC/EAN.js",
"EAN13.js": "bin/barcodes/EAN_UPC/EAN13.js",
"EAN2.js": "bin/barcodes/EAN_UPC/EAN2.js",
"EAN5.js": "bin/barcodes/EAN_UPC/EAN5.js",
"EAN8.js": "bin/barcodes/EAN_UPC/EAN8.js",
"encoder.js": "bin/barcodes/EAN_UPC/encoder.js",
"UPC.js": "bin/barcodes/EAN_UPC/UPC.js",
"UPCE.js": "bin/barcodes/EAN_UPC/UPCE.js",
"GenericBarcode": "bin/barcodes/GenericBarcode",
"index.tmp.js": "bin/barcodes/index.tmp.js",
"ITF": "bin/barcodes/ITF",
"ITF.js": "bin/barcodes/ITF/ITF.js",
"ITF14.js": "bin/barcodes/ITF/ITF14.js",
"MSI": "bin/barcodes/MSI",
"checksums.js": "bin/barcodes/MSI/checksums.js",
"MSI.js": "bin/barcodes/MSI/MSI.js",
"MSI10.js": "bin/barcodes/MSI/MSI10.js",
"MSI1010.js": "bin/barcodes/MSI/MSI1010.js",
"MSI11.js": "bin/barcodes/MSI/MSI11.js",
"MSI1110.js": "bin/barcodes/MSI/MSI1110.js",
"pharmacode": "bin/barcodes/pharmacode",
"exceptions": "bin/exceptions",
"ErrorHandler.js": "bin/exceptions/ErrorHandler.js",
"exceptions.js": "bin/exceptions/exceptions.js",
"help": "bin/help",
"fixOptions.js": "bin/help/fixOptions.js",
"getOptionsFromElement.js": "bin/help/getOptionsFromElement.js",
"getRenderProperties.js": "bin/help/getRenderProperties.js",
"linearizeEncodings.js": "bin/help/linearizeEncodings.js",
"merge.js": "bin/help/merge.js",
"optionsFromStrings.js": "bin/help/optionsFromStrings.js",
"JsBarcode.js": "bin/JsBarcode.js",
"options": "bin/options",
"defaults.js": "bin/options/defaults.js",
"renderers": "bin/renderers",
"canvas.js": "bin/renderers/canvas.js",
"object.js": "bin/renderers/object.js",
"shared.js": "bin/renderers/shared.js",
"svg.js": "bin/renderers/svg.js"
},
"bugs": {
"url": "https://github.com/lindell/JsBarcode/issues"
},
"bundleDependencies": false,
"config": {
"blanket": {
"pattern": [
"JsBarcode.js",
"barcodes"
],
"data-cover-never": [
"GenericBarcode",
"node_modules"
]
}
},
"deprecated": false,
"description": "JsBarcode is a customizable barcode generator with support for multiple barcode formats.",
"devDependencies": {
"babel-cli": "^6.24.1",
"babel-core": "^6.24.1",
"babel-loader": "^7.0.0",
"babel-preset-es2015": "^6.24.1",
"babel-preset-stage-3": "6.24.1",
"blanket": "^1.2.3",
"canvas": "^2.6.1",
"coveralls": "^3.1.0",
"gulp": "^4.0.2",
"gulp-babel": "^6.1.2",
"gulp-bump": "^3.2.0",
"gulp-clean": "^0.4.0",
"gulp-concat": "^2.6.1",
"gulp-eslint": "^6.0.0",
"gulp-git": "^2.10.1",
"gulp-header": "^2.0.9",
"gulp-rename": "^2.0.0",
"gulp-uglify": "^3.0.2",
"gulp4-run-sequence": "^1.0.0",
"gzip-size": "^5.1.1",
"mocha": "^8.1.1",
"mocha-lcov-reporter": "^1.3.0",
"publish-release": "^1.6.1",
"request": "^2.88.2",
"webpack": "^4.44.1",
"webpack-stream": "^5.2.1",
"xmldom": "^0.1.31"
},
"directories": {
"example": "example",
"test": "test",
"lib": "src",
"bin": "bin"
},
"homepage": "https://github.com/lindell/JsBarcode#readme",
"keywords": [
"barcode",
"canvas",
"code128",
"upc",
"ean",
"itf",
"msi",
"pharmacode"
],
"license": "MIT",
"main": "./bin/JsBarcode.js",
"name": "jsbarcode",
"repository": {
"type": "git",
"url": "git+https://github.com/lindell/JsBarcode.git"
},
"scripts": {
"build": "gulp compile",
"coverage": "mocha test/node/ -r blanket -R html-cov > test/coverage.html",
"coveralls": "NODE_ENV=test YOURPACKAGE_COVERAGE=1 ./node_modules/.bin/mocha test/node/ --require blanket --reporter mocha-lcov-reporter | ./node_modules/coveralls/bin/coveralls.js",
"test": "gulp babel && node_modules/mocha/bin/mocha test/node/ -R spec"
},
"typings": "./jsbarcode.d.ts",
"version": "3.11.5"
}

225
node_modules/jsbarcode/src/JsBarcode.js generated vendored Normal file
View File

@@ -0,0 +1,225 @@
// Import all the barcodes
import barcodes from './barcodes/';
// Help functions
import merge from './help/merge.js';
import linearizeEncodings from './help/linearizeEncodings.js';
import fixOptions from './help/fixOptions.js';
import getRenderProperties from './help/getRenderProperties.js';
import optionsFromStrings from './help/optionsFromStrings.js';
// Exceptions
import ErrorHandler from './exceptions/ErrorHandler.js';
import {InvalidInputException, NoElementException} from './exceptions/exceptions.js';
// Default values
import defaults from './options/defaults.js';
// The protype of the object returned from the JsBarcode() call
let API = function(){};
// The first call of the library API
// Will return an object with all barcodes calls and the data that is used
// by the renderers
let JsBarcode = function(element, text, options){
var api = new API();
if(typeof element === "undefined"){
throw Error("No element to render on was provided.");
}
// Variables that will be pased through the API calls
api._renderProperties = getRenderProperties(element);
api._encodings = [];
api._options = defaults;
api._errorHandler = new ErrorHandler(api);
// If text is set, use the simple syntax (render the barcode directly)
if(typeof text !== "undefined"){
options = options || {};
if(!options.format){
options.format = autoSelectBarcode();
}
api.options(options)[options.format](text, options).render();
}
return api;
};
// To make tests work TODO: remove
JsBarcode.getModule = function(name){
return barcodes[name];
};
// Register all barcodes
for(var name in barcodes){
if(barcodes.hasOwnProperty(name)){ // Security check if the propery is a prototype property
registerBarcode(barcodes, name);
}
}
function registerBarcode(barcodes, name){
API.prototype[name] =
API.prototype[name.toUpperCase()] =
API.prototype[name.toLowerCase()] =
function(text, options){
var api = this;
return api._errorHandler.wrapBarcodeCall(function(){
// Ensure text is options.text
options.text = typeof options.text === 'undefined' ? undefined : '' + options.text;
var newOptions = merge(api._options, options);
newOptions = optionsFromStrings(newOptions);
var Encoder = barcodes[name];
var encoded = encode(text, Encoder, newOptions);
api._encodings.push(encoded);
return api;
});
};
}
// encode() handles the Encoder call and builds the binary string to be rendered
function encode(text, Encoder, options){
// Ensure that text is a string
text = "" + text;
var encoder = new Encoder(text, options);
// If the input is not valid for the encoder, throw error.
// If the valid callback option is set, call it instead of throwing error
if(!encoder.valid()){
throw new InvalidInputException(encoder.constructor.name, text);
}
// Make a request for the binary data (and other infromation) that should be rendered
var encoded = encoder.encode();
// Encodings can be nestled like [[1-1, 1-2], 2, [3-1, 3-2]
// Convert to [1-1, 1-2, 2, 3-1, 3-2]
encoded = linearizeEncodings(encoded);
// Merge
for(let i = 0; i < encoded.length; i++){
encoded[i].options = merge(options, encoded[i].options);
}
return encoded;
}
function autoSelectBarcode(){
// If CODE128 exists. Use it
if(barcodes["CODE128"]){
return "CODE128";
}
// Else, take the first (probably only) barcode
return Object.keys(barcodes)[0];
}
// Sets global encoder options
// Added to the api by the JsBarcode function
API.prototype.options = function(options){
this._options = merge(this._options, options);
return this;
};
// Will create a blank space (usually in between barcodes)
API.prototype.blank = function(size){
const zeroes = new Array(size + 1).join("0");
this._encodings.push({data: zeroes});
return this;
};
// Initialize JsBarcode on all HTML elements defined.
API.prototype.init = function(){
// Should do nothing if no elements where found
if(!this._renderProperties){
return;
}
// Make sure renderProperies is an array
if(!Array.isArray(this._renderProperties)){
this._renderProperties = [this._renderProperties];
}
var renderProperty;
for(let i in this._renderProperties){
renderProperty = this._renderProperties[i];
var options = merge(this._options, renderProperty.options);
if(options.format == "auto"){
options.format = autoSelectBarcode();
}
this._errorHandler.wrapBarcodeCall(function(){
var text = options.value;
var Encoder = barcodes[options.format.toUpperCase()];
var encoded = encode(text, Encoder, options);
render(renderProperty, encoded, options);
});
}
};
// The render API call. Calls the real render function.
API.prototype.render = function(){
if(!this._renderProperties){
throw new NoElementException();
}
if(Array.isArray(this._renderProperties)){
for(var i = 0; i < this._renderProperties.length; i++){
render(this._renderProperties[i], this._encodings, this._options);
}
}
else{
render(this._renderProperties, this._encodings, this._options);
}
return this;
};
API.prototype._defaults = defaults;
// Prepares the encodings and calls the renderer
function render(renderProperties, encodings, options){
encodings = linearizeEncodings(encodings);
for(let i = 0; i < encodings.length; i++){
encodings[i].options = merge(options, encodings[i].options);
fixOptions(encodings[i].options);
}
fixOptions(options);
var Renderer = renderProperties.renderer;
var renderer = new Renderer(renderProperties.element, encodings, options);
renderer.render();
if(renderProperties.afterRender){
renderProperties.afterRender();
}
}
// Export to browser
if(typeof window !== "undefined"){
window.JsBarcode = JsBarcode;
}
// Export to jQuery
/*global jQuery */
if (typeof jQuery !== 'undefined') {
jQuery.fn.JsBarcode = function(content, options){
var elementArray = [];
jQuery(this).each(function() {
elementArray.push(this);
});
return JsBarcode(elementArray, content, options);
};
}
// Export to commonJS
module.exports = JsBarcode;

9
node_modules/jsbarcode/src/barcodes/Barcode.js generated vendored Normal file
View File

@@ -0,0 +1,9 @@
class Barcode{
constructor(data, options){
this.data = data;
this.text = options.text || data;
this.options = options;
}
}
export default Barcode;

127
node_modules/jsbarcode/src/barcodes/CODE128/CODE128.js generated vendored Normal file
View File

@@ -0,0 +1,127 @@
import Barcode from "../Barcode.js";
import { SHIFT, SET_A, SET_B, MODULO, STOP, FNC1, SET_BY_CODE, SWAP, BARS } from './constants';
// This is the master class,
// it does require the start code to be included in the string
class CODE128 extends Barcode {
constructor(data, options) {
super(data.substring(1), options);
// Get array of ascii codes from data
this.bytes = data.split('')
.map(char => char.charCodeAt(0));
}
valid() {
// ASCII value ranges 0-127, 200-211
return /^[\x00-\x7F\xC8-\xD3]+$/.test(this.data);
}
// The public encoding function
encode() {
const bytes = this.bytes;
// Remove the start code from the bytes and set its index
const startIndex = bytes.shift() - 105;
// Get start set by index
const startSet = SET_BY_CODE[startIndex];
if (startSet === undefined) {
throw new RangeError('The encoding does not start with a start character.');
}
if (this.shouldEncodeAsEan128() === true) {
bytes.unshift(FNC1);
}
// Start encode with the right type
const encodingResult = CODE128.next(bytes, 1, startSet);
return {
text:
this.text === this.data
? this.text.replace(/[^\x20-\x7E]/g, '')
: this.text,
data:
// Add the start bits
CODE128.getBar(startIndex) +
// Add the encoded bits
encodingResult.result +
// Add the checksum
CODE128.getBar((encodingResult.checksum + startIndex) % MODULO) +
// Add the end bits
CODE128.getBar(STOP)
};
}
// GS1-128/EAN-128
shouldEncodeAsEan128() {
let isEAN128 = this.options.ean128 || false;
if (typeof isEAN128 === 'string') {
isEAN128 = isEAN128.toLowerCase() === 'true';
}
return isEAN128;
}
// Get a bar symbol by index
static getBar(index) {
return BARS[index] ? BARS[index].toString() : '';
}
// Correct an index by a set and shift it from the bytes array
static correctIndex(bytes, set) {
if (set === SET_A) {
const charCode = bytes.shift();
return charCode < 32 ? charCode + 64 : charCode - 32;
} else if (set === SET_B) {
return bytes.shift() - 32;
} else {
return (bytes.shift() - 48) * 10 + bytes.shift() - 48;
}
}
static next(bytes, pos, set) {
if (!bytes.length) {
return { result: '', checksum: 0 };
}
let nextCode, index;
// Special characters
if (bytes[0] >= 200){
index = bytes.shift() - 105;
const nextSet = SWAP[index];
// Swap to other set
if (nextSet !== undefined) {
nextCode = CODE128.next(bytes, pos + 1, nextSet);
}
// Continue on current set but encode a special character
else {
// Shift
if ((set === SET_A || set === SET_B) && index === SHIFT) {
// Convert the next character so that is encoded correctly
bytes[0] = (set === SET_A)
? bytes[0] > 95 ? bytes[0] - 96 : bytes[0]
: bytes[0] < 32 ? bytes[0] + 96 : bytes[0];
}
nextCode = CODE128.next(bytes, pos + 1, set);
}
}
// Continue encoding
else {
index = CODE128.correctIndex(bytes, set);
nextCode = CODE128.next(bytes, pos + 1, set);
}
// Get the correct binary encoding and calculate the weight
const enc = CODE128.getBar(index);
const weight = index * pos;
return {
result: enc + nextCode.result,
checksum: weight + nextCode.checksum
};
}
}
export default CODE128;

View File

@@ -0,0 +1,14 @@
import CODE128 from './CODE128.js';
import { A_START_CHAR, A_CHARS } from './constants';
class CODE128A extends CODE128 {
constructor(string, options) {
super(A_START_CHAR + string, options);
}
valid() {
return (new RegExp(`^${A_CHARS}+$`)).test(this.data);
}
}
export default CODE128A;

View File

@@ -0,0 +1,14 @@
import CODE128 from './CODE128.js';
import { B_START_CHAR, B_CHARS } from './constants';
class CODE128B extends CODE128 {
constructor(string, options) {
super(B_START_CHAR + string, options);
}
valid() {
return (new RegExp(`^${B_CHARS}+$`)).test(this.data);
}
}
export default CODE128B;

View File

@@ -0,0 +1,14 @@
import CODE128 from './CODE128.js';
import { C_START_CHAR, C_CHARS } from './constants';
class CODE128C extends CODE128 {
constructor(string, options) {
super(C_START_CHAR + string, options);
}
valid() {
return (new RegExp(`^${C_CHARS}+$`)).test(this.data);
}
}
export default CODE128C;

View File

@@ -0,0 +1,15 @@
import CODE128 from './CODE128';
import autoSelectModes from './auto';
class CODE128AUTO extends CODE128{
constructor(data, options){
// ASCII value ranges 0-127, 200-211
if (/^[\x00-\x7F\xC8-\xD3]+$/.test(data)) {
super(autoSelectModes(data), options);
} else{
super(data, options);
}
}
}
export default CODE128AUTO;

68
node_modules/jsbarcode/src/barcodes/CODE128/auto.js generated vendored Normal file
View File

@@ -0,0 +1,68 @@
import { A_START_CHAR, B_START_CHAR, C_START_CHAR, A_CHARS, B_CHARS, C_CHARS } from './constants';
// Match Set functions
const matchSetALength = (string) => string.match(new RegExp(`^${A_CHARS}*`))[0].length;
const matchSetBLength = (string) => string.match(new RegExp(`^${B_CHARS}*`))[0].length;
const matchSetC = (string) => string.match(new RegExp(`^${C_CHARS}*`))[0];
// CODE128A or CODE128B
function autoSelectFromAB(string, isA){
const ranges = isA ? A_CHARS : B_CHARS;
const untilC = string.match(new RegExp(`^(${ranges}+?)(([0-9]{2}){2,})([^0-9]|$)`));
if (untilC) {
return (
untilC[1] +
String.fromCharCode(204) +
autoSelectFromC(string.substring(untilC[1].length))
);
}
const chars = string.match(new RegExp(`^${ranges}+`))[0];
if (chars.length === string.length) {
return string;
}
return (
chars +
String.fromCharCode(isA ? 205 : 206) +
autoSelectFromAB(string.substring(chars.length), !isA)
);
}
// CODE128C
function autoSelectFromC(string) {
const cMatch = matchSetC(string);
const length = cMatch.length;
if (length === string.length) {
return string;
}
string = string.substring(length);
// Select A/B depending on the longest match
const isA = matchSetALength(string) >= matchSetBLength(string);
return cMatch + String.fromCharCode(isA ? 206 : 205) + autoSelectFromAB(string, isA);
}
// Detect Code Set (A, B or C) and format the string
export default (string) => {
let newString;
const cLength = matchSetC(string).length;
// Select 128C if the string start with enough digits
if (cLength >= 2) {
newString = C_START_CHAR + autoSelectFromC(string);
} else {
// Select A/B depending on the longest match
const isA = matchSetALength(string) > matchSetBLength(string);
newString = (isA ? A_START_CHAR : B_START_CHAR) + autoSelectFromAB(string, isA);
}
return newString.replace(
/[\xCD\xCE]([^])[\xCD\xCE]/, // Any sequence between 205 and 206 characters
(match, char) => String.fromCharCode(203) + char
);
};

View File

@@ -0,0 +1,71 @@
// constants for internal usage
export const SET_A = 0;
export const SET_B = 1;
export const SET_C = 2;
// Special characters
export const SHIFT = 98;
export const START_A = 103;
export const START_B = 104;
export const START_C = 105;
export const MODULO = 103;
export const STOP = 106;
export const FNC1 = 207;
// Get set by start code
export const SET_BY_CODE = {
[START_A]: SET_A,
[START_B]: SET_B,
[START_C]: SET_C,
};
// Get next set by code
export const SWAP = {
101: SET_A,
100: SET_B,
99: SET_C,
};
export const A_START_CHAR = String.fromCharCode(208); // START_A + 105
export const B_START_CHAR = String.fromCharCode(209); // START_B + 105
export const C_START_CHAR = String.fromCharCode(210); // START_C + 105
// 128A (Code Set A)
// ASCII characters 00 to 95 (09, AZ and control codes), special characters, and FNC 14
export const A_CHARS = "[\x00-\x5F\xC8-\xCF]";
// 128B (Code Set B)
// ASCII characters 32 to 127 (09, AZ, az), special characters, and FNC 14
export const B_CHARS = "[\x20-\x7F\xC8-\xCF]";
// 128C (Code Set C)
// 0099 (encodes two digits with a single code point) and FNC1
export const C_CHARS = "(\xCF*[0-9]{2}\xCF*)";
// CODE128 includes 107 symbols:
// 103 data symbols, 3 start symbols (A, B and C), and 1 stop symbol (the last one)
// Each symbol consist of three black bars (1) and three white spaces (0).
export const BARS = [
11011001100, 11001101100, 11001100110, 10010011000, 10010001100,
10001001100, 10011001000, 10011000100, 10001100100, 11001001000,
11001000100, 11000100100, 10110011100, 10011011100, 10011001110,
10111001100, 10011101100, 10011100110, 11001110010, 11001011100,
11001001110, 11011100100, 11001110100, 11101101110, 11101001100,
11100101100, 11100100110, 11101100100, 11100110100, 11100110010,
11011011000, 11011000110, 11000110110, 10100011000, 10001011000,
10001000110, 10110001000, 10001101000, 10001100010, 11010001000,
11000101000, 11000100010, 10110111000, 10110001110, 10001101110,
10111011000, 10111000110, 10001110110, 11101110110, 11010001110,
11000101110, 11011101000, 11011100010, 11011101110, 11101011000,
11101000110, 11100010110, 11101101000, 11101100010, 11100011010,
11101111010, 11001000010, 11110001010, 10100110000, 10100001100,
10010110000, 10010000110, 10000101100, 10000100110, 10110010000,
10110000100, 10011010000, 10011000010, 10000110100, 10000110010,
11000010010, 11001010000, 11110111010, 11000010100, 10001111010,
10100111100, 10010111100, 10010011110, 10111100100, 10011110100,
10011110010, 11110100100, 11110010100, 11110010010, 11011011110,
11011110110, 11110110110, 10101111000, 10100011110, 10001011110,
10111101000, 10111100010, 11110101000, 11110100010, 10111011110,
10111101110, 11101011110, 11110101110, 11010000100, 11010010000,
11010011100, 1100011101011
];

6
node_modules/jsbarcode/src/barcodes/CODE128/index.js generated vendored Normal file
View File

@@ -0,0 +1,6 @@
import CODE128 from './CODE128_AUTO.js';
import CODE128A from './CODE128A.js';
import CODE128B from './CODE128B.js';
import CODE128C from './CODE128C.js';
export {CODE128, CODE128A, CODE128B, CODE128C};

105
node_modules/jsbarcode/src/barcodes/CODE39/index.js generated vendored Normal file
View File

@@ -0,0 +1,105 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/Code_39#Encoding
import Barcode from "../Barcode.js";
class CODE39 extends Barcode {
constructor(data, options){
data = data.toUpperCase();
// Calculate mod43 checksum if enabled
if(options.mod43){
data += getCharacter(mod43checksum(data));
}
super(data, options);
}
encode(){
// First character is always a *
var result = getEncoding("*");
// Take every character and add the binary representation to the result
for(let i = 0; i < this.data.length; i++){
result += getEncoding(this.data[i]) + "0";
}
// Last character is always a *
result += getEncoding("*");
return {
data: result,
text: this.text
};
}
valid(){
return this.data.search(/^[0-9A-Z\-\.\ \$\/\+\%]+$/) !== -1;
}
}
// All characters. The position in the array is the (checksum) value
var characters = [
"0", "1", "2", "3",
"4", "5", "6", "7",
"8", "9", "A", "B",
"C", "D", "E", "F",
"G", "H", "I", "J",
"K", "L", "M", "N",
"O", "P", "Q", "R",
"S", "T", "U", "V",
"W", "X", "Y", "Z",
"-", ".", " ", "$",
"/", "+", "%", "*"
];
// The decimal representation of the characters, is converted to the
// corresponding binary with the getEncoding function
var encodings = [
20957, 29783, 23639, 30485,
20951, 29813, 23669, 20855,
29789, 23645, 29975, 23831,
30533, 22295, 30149, 24005,
21623, 29981, 23837, 22301,
30023, 23879, 30545, 22343,
30161, 24017, 21959, 30065,
23921, 22385, 29015, 18263,
29141, 17879, 29045, 18293,
17783, 29021, 18269, 17477,
17489, 17681, 20753, 35770
];
// Get the binary representation of a character by converting the encodings
// from decimal to binary
function getEncoding(character){
return getBinary(characterValue(character));
}
function getBinary(characterValue){
return encodings[characterValue].toString(2);
}
function getCharacter(characterValue){
return characters[characterValue];
}
function characterValue(character){
return characters.indexOf(character);
}
function mod43checksum(data){
var checksum = 0;
for(let i = 0; i < data.length; i++){
checksum += characterValue(data[i]);
}
checksum = checksum % 43;
return checksum;
}
export {CODE39};

72
node_modules/jsbarcode/src/barcodes/EAN_UPC/EAN.js generated vendored Normal file
View File

@@ -0,0 +1,72 @@
import { SIDE_BIN, MIDDLE_BIN } from './constants';
import encode from './encoder';
import Barcode from '../Barcode';
// Base class for EAN8 & EAN13
class EAN extends Barcode {
constructor(data, options) {
super(data, options);
// Make sure the font is not bigger than the space between the guard bars
this.fontSize = !options.flat && options.fontSize > options.width * 10
? options.width * 10
: options.fontSize;
// Make the guard bars go down half the way of the text
this.guardHeight = options.height + this.fontSize / 2 + options.textMargin;
}
encode() {
return this.options.flat
? this.encodeFlat()
: this.encodeGuarded();
}
leftText(from, to) {
return this.text.substr(from, to);
}
leftEncode(data, structure) {
return encode(data, structure);
}
rightText(from, to) {
return this.text.substr(from, to);
}
rightEncode(data, structure) {
return encode(data, structure);
}
encodeGuarded() {
const textOptions = { fontSize: this.fontSize };
const guardOptions = { height: this.guardHeight };
return [
{ data: SIDE_BIN, options: guardOptions },
{ data: this.leftEncode(), text: this.leftText(), options: textOptions },
{ data: MIDDLE_BIN, options: guardOptions },
{ data: this.rightEncode(), text: this.rightText(), options: textOptions },
{ data: SIDE_BIN, options: guardOptions },
];
}
encodeFlat() {
const data = [
SIDE_BIN,
this.leftEncode(),
MIDDLE_BIN,
this.rightEncode(),
SIDE_BIN
];
return {
data: data.join(''),
text: this.text
};
}
}
export default EAN;

90
node_modules/jsbarcode/src/barcodes/EAN_UPC/EAN13.js generated vendored Normal file
View File

@@ -0,0 +1,90 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Binary_encoding_of_data_digits_into_EAN-13_barcode
import { EAN13_STRUCTURE } from './constants';
import EAN from './EAN';
// Calculate the checksum digit
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Calculation_of_checksum_digit
const checksum = (number) => {
const res = number
.substr(0, 12)
.split('')
.map((n) => +n)
.reduce((sum, a, idx) => (
idx % 2 ? sum + a * 3 : sum + a
), 0);
return (10 - (res % 10)) % 10;
};
class EAN13 extends EAN {
constructor(data, options) {
// Add checksum if it does not exist
if (data.search(/^[0-9]{12}$/) !== -1) {
data += checksum(data);
}
super(data, options);
// Adds a last character to the end of the barcode
this.lastChar = options.lastChar;
}
valid() {
return (
this.data.search(/^[0-9]{13}$/) !== -1 &&
+this.data[12] === checksum(this.data)
);
}
leftText() {
return super.leftText(1, 6);
}
leftEncode() {
const data = this.data.substr(1, 6);
const structure = EAN13_STRUCTURE[this.data[0]];
return super.leftEncode(data, structure);
}
rightText() {
return super.rightText(7, 6);
}
rightEncode() {
const data = this.data.substr(7, 6);
return super.rightEncode(data, 'RRRRRR');
}
// The "standard" way of printing EAN13 barcodes with guard bars
encodeGuarded() {
const data = super.encodeGuarded();
// Extend data with left digit & last character
if (this.options.displayValue) {
data.unshift({
data: '000000000000',
text: this.text.substr(0, 1),
options: { textAlign: 'left', fontSize: this.fontSize }
});
if (this.options.lastChar) {
data.push({
data: '00'
});
data.push({
data: '00000',
text: this.options.lastChar,
options: { fontSize: this.fontSize }
});
}
}
return data;
}
}
export default EAN13;

30
node_modules/jsbarcode/src/barcodes/EAN_UPC/EAN2.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/EAN_2#Encoding
import { EAN2_STRUCTURE } from './constants';
import encode from './encoder';
import Barcode from '../Barcode';
class EAN2 extends Barcode {
constructor(data, options) {
super(data, options);
}
valid() {
return this.data.search(/^[0-9]{2}$/) !== -1;
}
encode(){
// Choose the structure based on the number mod 4
const structure = EAN2_STRUCTURE[parseInt(this.data) % 4];
return {
// Start bits + Encode the two digits with 01 in between
data: '1011' + encode(this.data, structure, '01'),
text: this.text
};
}
}
export default EAN2;

40
node_modules/jsbarcode/src/barcodes/EAN_UPC/EAN5.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/EAN_5#Encoding
import { EAN5_STRUCTURE } from './constants';
import encode from './encoder';
import Barcode from '../Barcode';
const checksum = (data) => {
const result = data
.split('')
.map(n => +n)
.reduce((sum, a, idx) => {
return idx % 2
? sum + a * 9
: sum + a * 3;
}, 0);
return result % 10;
};
class EAN5 extends Barcode {
constructor(data, options) {
super(data, options);
}
valid() {
return this.data.search(/^[0-9]{5}$/) !== -1;
}
encode() {
const structure = EAN5_STRUCTURE[checksum(this.data)];
return {
data: '1011' + encode(this.data, structure, '01'),
text: this.text
};
}
}
export default EAN5;

57
node_modules/jsbarcode/src/barcodes/EAN_UPC/EAN8.js generated vendored Normal file
View File

@@ -0,0 +1,57 @@
// Encoding documentation:
// http://www.barcodeisland.com/ean8.phtml
import EAN from './EAN';
// Calculate the checksum digit
const checksum = (number) => {
const res = number
.substr(0, 7)
.split('')
.map((n) => +n)
.reduce((sum, a, idx) => (
idx % 2 ? sum + a : sum + a * 3
), 0);
return (10 - (res % 10)) % 10;
};
class EAN8 extends EAN {
constructor(data, options) {
// Add checksum if it does not exist
if (data.search(/^[0-9]{7}$/) !== -1) {
data += checksum(data);
}
super(data, options);
}
valid() {
return (
this.data.search(/^[0-9]{8}$/) !== -1 &&
+this.data[7] === checksum(this.data)
);
}
leftText() {
return super.leftText(0, 4);
}
leftEncode() {
const data = this.data.substr(0, 4);
return super.leftEncode(data, 'LLLL');
}
rightText() {
return super.rightText(4, 4);
}
rightEncode() {
const data = this.data.substr(4, 4);
return super.rightEncode(data, 'RRRR');
}
}
export default EAN8;

132
node_modules/jsbarcode/src/barcodes/EAN_UPC/UPC.js generated vendored Normal file
View File

@@ -0,0 +1,132 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#Encoding
import encode from './encoder';
import Barcode from "../Barcode.js";
class UPC extends Barcode{
constructor(data, options){
// Add checksum if it does not exist
if(data.search(/^[0-9]{11}$/) !== -1){
data += checksum(data);
}
super(data, options);
this.displayValue = options.displayValue;
// Make sure the font is not bigger than the space between the guard bars
if(options.fontSize > options.width * 10){
this.fontSize = options.width * 10;
}
else{
this.fontSize = options.fontSize;
}
// Make the guard bars go down half the way of the text
this.guardHeight = options.height + this.fontSize / 2 + options.textMargin;
}
valid(){
return this.data.search(/^[0-9]{12}$/) !== -1 &&
this.data[11] == checksum(this.data);
}
encode(){
if(this.options.flat){
return this.flatEncoding();
}
else{
return this.guardedEncoding();
}
}
flatEncoding(){
var result = "";
result += "101";
result += encode(this.data.substr(0, 6), "LLLLLL");
result += "01010";
result += encode(this.data.substr(6, 6), "RRRRRR");
result += "101";
return {
data: result,
text: this.text
};
}
guardedEncoding(){
var result = [];
// Add the first digit
if(this.displayValue){
result.push({
data: "00000000",
text: this.text.substr(0, 1),
options: {textAlign: "left", fontSize: this.fontSize}
});
}
// Add the guard bars
result.push({
data: "101" + encode(this.data[0], "L"),
options: {height: this.guardHeight}
});
// Add the left side
result.push({
data: encode(this.data.substr(1, 5), "LLLLL"),
text: this.text.substr(1, 5),
options: {fontSize: this.fontSize}
});
// Add the middle bits
result.push({
data: "01010",
options: {height: this.guardHeight}
});
// Add the right side
result.push({
data: encode(this.data.substr(6, 5), "RRRRR"),
text: this.text.substr(6, 5),
options: {fontSize: this.fontSize}
});
// Add the end bits
result.push({
data: encode(this.data[11], "R") + "101",
options: {height: this.guardHeight}
});
// Add the last digit
if(this.displayValue){
result.push({
data: "00000000",
text: this.text.substr(11, 1),
options: {textAlign: "right", fontSize: this.fontSize}
});
}
return result;
}
}
// Calulate the checksum digit
// https://en.wikipedia.org/wiki/International_Article_Number_(EAN)#Calculation_of_checksum_digit
export function checksum(number){
var result = 0;
var i;
for(i = 1; i < 11; i += 2){
result += parseInt(number[i]);
}
for(i = 0; i < 11; i += 2){
result += parseInt(number[i]) * 3;
}
return (10 - (result % 10)) % 10;
}
export default UPC;

177
node_modules/jsbarcode/src/barcodes/EAN_UPC/UPCE.js generated vendored Normal file
View File

@@ -0,0 +1,177 @@
// Encoding documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#Encoding
//
// UPC-E documentation:
// https://en.wikipedia.org/wiki/Universal_Product_Code#UPC-E
import encode from './encoder';
import Barcode from "../Barcode.js";
import { checksum } from './UPC.js';
const EXPANSIONS = [
"XX00000XXX",
"XX10000XXX",
"XX20000XXX",
"XXX00000XX",
"XXXX00000X",
"XXXXX00005",
"XXXXX00006",
"XXXXX00007",
"XXXXX00008",
"XXXXX00009"
];
const PARITIES = [
["EEEOOO", "OOOEEE"],
["EEOEOO", "OOEOEE"],
["EEOOEO", "OOEEOE"],
["EEOOOE", "OOEEEO"],
["EOEEOO", "OEOOEE"],
["EOOEEO", "OEEOOE"],
["EOOOEE", "OEEEOO"],
["EOEOEO", "OEOEOE"],
["EOEOOE", "OEOEEO"],
["EOOEOE", "OEEOEO"]
];
class UPCE extends Barcode{
constructor(data, options){
// Code may be 6 or 8 digits;
// A 7 digit code is ambiguous as to whether the extra digit
// is a UPC-A check or number system digit.
super(data, options);
this.isValid = false;
if(data.search(/^[0-9]{6}$/) !== -1){
this.middleDigits = data;
this.upcA = expandToUPCA(data, "0");
this.text = options.text ||
`${this.upcA[0]}${data}${this.upcA[this.upcA.length - 1]}`;
this.isValid = true;
}
else if(data.search(/^[01][0-9]{7}$/) !== -1){
this.middleDigits = data.substring(1, data.length - 1);
this.upcA = expandToUPCA(this.middleDigits, data[0]);
if(this.upcA[this.upcA.length - 1] === data[data.length - 1]){
this.isValid = true;
}
else{
// checksum mismatch
return;
}
}
else{
return;
}
this.displayValue = options.displayValue;
// Make sure the font is not bigger than the space between the guard bars
if(options.fontSize > options.width * 10){
this.fontSize = options.width * 10;
}
else{
this.fontSize = options.fontSize;
}
// Make the guard bars go down half the way of the text
this.guardHeight = options.height + this.fontSize / 2 + options.textMargin;
}
valid(){
return this.isValid;
}
encode(){
if(this.options.flat){
return this.flatEncoding();
}
else{
return this.guardedEncoding();
}
}
flatEncoding(){
var result = "";
result += "101";
result += this.encodeMiddleDigits();
result += "010101";
return {
data: result,
text: this.text
};
}
guardedEncoding(){
var result = [];
// Add the UPC-A number system digit beneath the quiet zone
if(this.displayValue){
result.push({
data: "00000000",
text: this.text[0],
options: {textAlign: "left", fontSize: this.fontSize}
});
}
// Add the guard bars
result.push({
data: "101",
options: {height: this.guardHeight}
});
// Add the 6 UPC-E digits
result.push({
data: this.encodeMiddleDigits(),
text: this.text.substring(1, 7),
options: {fontSize: this.fontSize}
});
// Add the end bits
result.push({
data: "010101",
options: {height: this.guardHeight}
});
// Add the UPC-A check digit beneath the quiet zone
if(this.displayValue){
result.push({
data: "00000000",
text: this.text[7],
options: {textAlign: "right", fontSize: this.fontSize}
});
}
return result;
}
encodeMiddleDigits() {
const numberSystem = this.upcA[0];
const checkDigit = this.upcA[this.upcA.length - 1];
const parity = PARITIES[parseInt(checkDigit)][parseInt(numberSystem)];
return encode(this.middleDigits, parity);
}
}
function expandToUPCA(middleDigits, numberSystem) {
const lastUpcE = parseInt(middleDigits[middleDigits.length - 1]);
const expansion = EXPANSIONS[lastUpcE];
let result = "";
let digitIndex = 0;
for(let i = 0; i < expansion.length; i++) {
let c = expansion[i];
if (c === 'X') {
result += middleDigits[digitIndex++];
} else {
result += c;
}
}
result = `${numberSystem}${result}`;
return `${result}${checksum(result)}`;
}
export default UPCE;

Some files were not shown because too many files have changed in this diff Show More