myprint-design
Version:
操作简单，组件丰富的一站式打印解决方案打印设计器
1,257 lines (1,247 loc) • 4.39 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('vue-cropper/dist/index.css'), require('vue3-colorpicker/style.css')) :
typeof define === 'function' && define.amd ? define(['exports', 'vue', 'vue-cropper/dist/index.css', 'vue3-colorpicker/style.css'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MyPrinterDesign = {}, global.Vue));
})(this, (function (exports, vue) { 'use strict';
const MathCalc = {
toFixed(x, scale = 2) {
return parseFloat(x.toFixed(scale));
},
ceil(x, scale = 2) {
let pow = Math.pow(10, scale);
return Math.ceil(x * pow) / pow;
},
sumScale(arg1 = 0, arg2 = 0, scale = 2) {
return this.sum(this.toFixed(arg1, scale), this.toFixed(arg2, scale));
},
sum(arg1 = 0, arg2 = 0) {
let r1, r2;
try {
r1 = arg1.toString().split(".")[1].length;
} catch (e) {
r1 = 0;
}
try {
r2 = arg2.toString().split(".")[1].length;
} catch (e) {
r2 = 0;
}
const c = Math.abs(r1 - r2);
const m = Math.pow(10, Math.max(r1, r2));
if (c > 0) {
const cm = Math.pow(10, c);
if (r1 > r2) {
arg1 = Number(arg1.toString().replace(".", ""));
arg2 = Number(arg2.toString().replace(".", "")) * cm;
} else {
arg1 = Number(arg1.toString().replace(".", "")) * cm;
arg2 = Number(arg2.toString().replace(".", ""));
}
} else {
arg1 = Number(arg1.toString().replace(".", ""));
arg2 = Number(arg2.toString().replace(".", ""));
}
return (arg1 + arg2) / m;
},
subScale(arg1 = 0, arg2 = 0, scale = 2) {
return this.sub(this.toFixed(arg1, scale), this.toFixed(arg2, scale));
},
sub(arg1, arg2) {
let r1, r2;
try {
r1 = arg1.toString().split(".")[1].length;
} catch (e) {
r1 = 0;
}
try {
r2 = arg2.toString().split(".")[1].length;
} catch (e) {
r2 = 0;
}
const c = Math.abs(r1 - r2);
const m = Math.pow(10, Math.max(r1, r2));
if (c > 0) {
const cm = Math.pow(10, c);
if (r1 > r2) {
arg1 = Number(arg1.toString().replace(".", ""));
arg2 = Number(arg2.toString().replace(".", "")) * cm;
} else {
arg1 = Number(arg1.toString().replace(".", "")) * cm;
arg2 = Number(arg2.toString().replace(".", ""));
}
} else {
arg1 = Number(arg1.toString().replace(".", ""));
arg2 = Number(arg2.toString().replace(".", ""));
}
return (arg1 - arg2) / m;
},
mul(arg1, arg2, scale = 2) {
let m = 0;
const s1 = arg1.toString();
const s2 = arg2.toString();
try {
m += s1.split(".")[1].length;
} catch (e) {
}
try {
m += s2.split(".")[1].length;
} catch (e) {
}
return this.toFixed(Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m), scale);
},
div(arg1, arg2, scale = 2) {
let t1 = 0, t2 = 0;
try {
t1 = arg1.toString().split(".")[1].length;
} catch (e) {
}
try {
t2 = arg2.toString().split(".")[1].length;
} catch (e) {
}
const r1 = Number(arg1.toString().replace(".", ""));
const r2 = Number(arg2.toString().replace(".", ""));
return this.toFixed(r1 / r2 * Math.pow(10, t2 - t1), scale);
},
limitMin(val, min) {
return val < min ? min : val;
},
isNumber(value) {
return !isNaN(value);
}
};
function _defaultNum(val, _default2) {
return !val || isNaN(val) ? _default2 : val;
}
/*!
* shared v9.3.0
* (c) 2023 kazuya kawaguchi
* Released under the MIT License.
*/
/**
* Original Utilities
* written by kazuya kawaguchi
*/
const inBrowser = typeof window !== 'undefined';
const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
const friendlyJSONstringify = (json) => JSON.stringify(json)
.replace(/\u2028/g, '\\u2028')
.replace(/\u2029/g, '\\u2029')
.replace(/\u0027/g, '\\u0027');
const isNumber$2 = (val) => typeof val === 'number' && isFinite(val);
const isDate$1 = (val) => toTypeString(val) === '[object Date]';
const isRegExp$2 = (val) => toTypeString(val) === '[object RegExp]';
const isEmptyObject = (val) => isPlainObject$3(val) && Object.keys(val).length === 0;
const assign$2 = Object.assign;
let _globalThis;
const getGlobalThis = () => {
// prettier-ignore
return (_globalThis ||
(_globalThis =
typeof globalThis !== 'undefined'
? globalThis
: typeof self !== 'undefined'
? self
: typeof window !== 'undefined'
? window
: typeof global !== 'undefined'
? global
: {}));
};
function escapeHtml(rawText) {
return rawText
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
}
const hasOwnProperty$c = Object.prototype.hasOwnProperty;
function hasOwn$c(obj, key) {
return hasOwnProperty$c.call(obj, key);
}
/* eslint-enable */
/**
* Useful Utilities By Evan you
* Modified by kazuya kawaguchi
* MIT License
* https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
* https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
*/
const isArray$6 = Array.isArray;
const isFunction$3 = (val) => typeof val === 'function';
const isString$2 = (val) => typeof val === 'string';
const isBoolean$1 = (val) => typeof val === 'boolean';
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const isObject$i = (val) => val !== null && typeof val === 'object';
const objectToString$2 = Object.prototype.toString;
const toTypeString = (value) => objectToString$2.call(value);
const isPlainObject$3 = (val) => {
if (!isObject$i(val))
return false;
const proto = Object.getPrototypeOf(val);
return proto === null || proto.constructor === Object;
};
// for converting list and named values to displayed strings.
const toDisplayString = (val) => {
return val == null
? ''
: isArray$6(val) || (isPlainObject$3(val) && val.toString === objectToString$2)
? JSON.stringify(val, null, 2)
: String(val);
};
function join$1(items, separator = '') {
return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
}
function incrementer(code) {
let current = code;
return () => ++current;
}
function warn(msg, err) {
if (typeof console !== 'undefined') {
console.warn(`[intlify] ` + msg);
/* istanbul ignore if */
if (err) {
console.warn(err.stack);
}
}
}
/**
* Event emitter, forked from the below:
* - original repository url: https://github.com/developit/mitt
* - code url: https://github.com/developit/mitt/blob/master/src/index.ts
* - author: Jason Miller (https://github.com/developit)
* - license: MIT
*/
/**
* Create a event emitter
*
* @returns An event emitter
*/
function createEmitter() {
const events = new Map();
const emitter = {
events,
on(event, handler) {
const handlers = events.get(event);
const added = handlers && handlers.push(handler);
if (!added) {
events.set(event, [handler]);
}
},
off(event, handler) {
const handlers = events.get(event);
if (handlers) {
handlers.splice(handlers.indexOf(handler) >>> 0, 1);
}
},
emit(event, payload) {
(events.get(event) || [])
.slice()
.map(handler => handler(payload));
(events.get('*') || [])
.slice()
.map(handler => handler(event, payload));
}
};
return emitter;
}
/*!
* message-compiler v9.3.0
* (c) 2023 kazuya kawaguchi
* Released under the MIT License.
*/
function createPosition(line, column, offset) {
return { line, column, offset };
}
function createLocation(start, end, source) {
const loc = { start, end };
if (source != null) {
loc.source = source;
}
return loc;
}
const CompileErrorCodes = {
// tokenizer error codes
EXPECTED_TOKEN: 1,
INVALID_TOKEN_IN_PLACEHOLDER: 2,
UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
UNKNOWN_ESCAPE_SEQUENCE: 4,
INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
UNBALANCED_CLOSING_BRACE: 6,
UNTERMINATED_CLOSING_BRACE: 7,
EMPTY_PLACEHOLDER: 8,
NOT_ALLOW_NEST_PLACEHOLDER: 9,
INVALID_LINKED_FORMAT: 10,
// parser error codes
MUST_HAVE_MESSAGES_IN_PLURAL: 11,
UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
UNEXPECTED_EMPTY_LINKED_KEY: 13,
UNEXPECTED_LEXICAL_ANALYSIS: 14,
// generator error codes
UNHANDLED_CODEGEN_NODE_TYPE: 15,
// minifier error codes
UNHANDLED_MINIFIER_NODE_TYPE: 16,
// Special value for higher-order compilers to pick up the last code
// to avoid collision of error codes. This should always be kept as the last
// item.
__EXTEND_POINT__: 17
};
function createCompileError(code, loc, options = {}) {
const { domain, messages, args } = options;
const msg = code;
const error = new SyntaxError(String(msg));
error.code = code;
if (loc) {
error.location = loc;
}
error.domain = domain;
return error;
}
/** @internal */
function defaultOnError(error) {
throw error;
}
const CHAR_SP = ' ';
const CHAR_CR = '\r';
const CHAR_LF = '\n';
const CHAR_LS = String.fromCharCode(0x2028);
const CHAR_PS = String.fromCharCode(0x2029);
function createScanner(str) {
const _buf = str;
let _index = 0;
let _line = 1;
let _column = 1;
let _peekOffset = 0;
const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
const isLF = (index) => _buf[index] === CHAR_LF;
const isPS = (index) => _buf[index] === CHAR_PS;
const isLS = (index) => _buf[index] === CHAR_LS;
const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
const index = () => _index;
const line = () => _line;
const column = () => _column;
const peekOffset = () => _peekOffset;
const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
const currentChar = () => charAt(_index);
const currentPeek = () => charAt(_index + _peekOffset);
function next() {
_peekOffset = 0;
if (isLineEnd(_index)) {
_line++;
_column = 0;
}
if (isCRLF(_index)) {
_index++;
}
_index++;
_column++;
return _buf[_index];
}
function peek() {
if (isCRLF(_index + _peekOffset)) {
_peekOffset++;
}
_peekOffset++;
return _buf[_index + _peekOffset];
}
function reset() {
_index = 0;
_line = 1;
_column = 1;
_peekOffset = 0;
}
function resetPeek(offset = 0) {
_peekOffset = offset;
}
function skipToPeek() {
const target = _index + _peekOffset;
// eslint-disable-next-line no-unmodified-loop-condition
while (target !== _index) {
next();
}
_peekOffset = 0;
}
return {
index,
line,
column,
peekOffset,
charAt,
currentChar,
currentPeek,
next,
peek,
reset,
resetPeek,
skipToPeek
};
}
const EOF$1 = undefined;
const DOT = '.';
const LITERAL_DELIMITER = "'";
const ERROR_DOMAIN$3 = 'tokenizer';
function createTokenizer(source, options = {}) {
const location = options.location !== false;
const _scnr = createScanner(source);
const currentOffset = () => _scnr.index();
const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
const _initLoc = currentPosition();
const _initOffset = currentOffset();
const _context = {
currentType: 14 /* TokenTypes.EOF */,
offset: _initOffset,
startLoc: _initLoc,
endLoc: _initLoc,
lastType: 14 /* TokenTypes.EOF */,
lastOffset: _initOffset,
lastStartLoc: _initLoc,
lastEndLoc: _initLoc,
braceNest: 0,
inLinked: false,
text: ''
};
const context = () => _context;
const { onError } = options;
function emitError(code, pos, offset, ...args) {
const ctx = context();
pos.column += offset;
pos.offset += offset;
if (onError) {
const loc = location ? createLocation(ctx.startLoc, pos) : null;
const err = createCompileError(code, loc, {
domain: ERROR_DOMAIN$3,
args
});
onError(err);
}
}
function getToken(context, type, value) {
context.endLoc = currentPosition();
context.currentType = type;
const token = { type };
if (location) {
token.loc = createLocation(context.startLoc, context.endLoc);
}
if (value != null) {
token.value = value;
}
return token;
}
const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
function eat(scnr, ch) {
if (scnr.currentChar() === ch) {
scnr.next();
return ch;
}
else {
emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
return '';
}
}
function peekSpaces(scnr) {
let buf = '';
while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
buf += scnr.currentPeek();
scnr.peek();
}
return buf;
}
function skipSpaces(scnr) {
const buf = peekSpaces(scnr);
scnr.skipToPeek();
return buf;
}
function isIdentifierStart(ch) {
if (ch === EOF$1) {
return false;
}
const cc = ch.charCodeAt(0);
return ((cc >= 97 && cc <= 122) || // a-z
(cc >= 65 && cc <= 90) || // A-Z
cc === 95 // _
);
}
function isNumberStart(ch) {
if (ch === EOF$1) {
return false;
}
const cc = ch.charCodeAt(0);
return cc >= 48 && cc <= 57; // 0-9
}
function isNamedIdentifierStart(scnr, context) {
const { currentType } = context;
if (currentType !== 2 /* TokenTypes.BraceLeft */) {
return false;
}
peekSpaces(scnr);
const ret = isIdentifierStart(scnr.currentPeek());
scnr.resetPeek();
return ret;
}
function isListIdentifierStart(scnr, context) {
const { currentType } = context;
if (currentType !== 2 /* TokenTypes.BraceLeft */) {
return false;
}
peekSpaces(scnr);
const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
const ret = isNumberStart(ch);
scnr.resetPeek();
return ret;
}
function isLiteralStart(scnr, context) {
const { currentType } = context;
if (currentType !== 2 /* TokenTypes.BraceLeft */) {
return false;
}
peekSpaces(scnr);
const ret = scnr.currentPeek() === LITERAL_DELIMITER;
scnr.resetPeek();
return ret;
}
function isLinkedDotStart(scnr, context) {
const { currentType } = context;
if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
return false;
}
peekSpaces(scnr);
const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
scnr.resetPeek();
return ret;
}
function isLinkedModifierStart(scnr, context) {
const { currentType } = context;
if (currentType !== 9 /* TokenTypes.LinkedDot */) {
return false;
}
peekSpaces(scnr);
const ret = isIdentifierStart(scnr.currentPeek());
scnr.resetPeek();
return ret;
}
function isLinkedDelimiterStart(scnr, context) {
const { currentType } = context;
if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
currentType === 12 /* TokenTypes.LinkedModifier */)) {
return false;
}
peekSpaces(scnr);
const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
scnr.resetPeek();
return ret;
}
function isLinkedReferStart(scnr, context) {
const { currentType } = context;
if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
return false;
}
const fn = () => {
const ch = scnr.currentPeek();
if (ch === "{" /* TokenChars.BraceLeft */) {
return isIdentifierStart(scnr.peek());
}
else if (ch === "@" /* TokenChars.LinkedAlias */ ||
ch === "%" /* TokenChars.Modulo */ ||
ch === "|" /* TokenChars.Pipe */ ||
ch === ":" /* TokenChars.LinkedDelimiter */ ||
ch === "." /* TokenChars.LinkedDot */ ||
ch === CHAR_SP ||
!ch) {
return false;
}
else if (ch === CHAR_LF) {
scnr.peek();
return fn();
}
else {
// other characters
return isIdentifierStart(ch);
}
};
const ret = fn();
scnr.resetPeek();
return ret;
}
function isPluralStart(scnr) {
peekSpaces(scnr);
const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
scnr.resetPeek();
return ret;
}
function detectModuloStart(scnr) {
const spaces = peekSpaces(scnr);
const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
scnr.peek() === "{" /* TokenChars.BraceLeft */;
scnr.resetPeek();
return {
isModulo: ret,
hasSpace: spaces.length > 0
};
}
function isTextStart(scnr, reset = true) {
const fn = (hasSpace = false, prev = '', detectModulo = false) => {
const ch = scnr.currentPeek();
if (ch === "{" /* TokenChars.BraceLeft */) {
return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
}
else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
}
else if (ch === "%" /* TokenChars.Modulo */) {
scnr.peek();
return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
}
else if (ch === "|" /* TokenChars.Pipe */) {
return prev === "%" /* TokenChars.Modulo */ || detectModulo
? true
: !(prev === CHAR_SP || prev === CHAR_LF);
}
else if (ch === CHAR_SP) {
scnr.peek();
return fn(true, CHAR_SP, detectModulo);
}
else if (ch === CHAR_LF) {
scnr.peek();
return fn(true, CHAR_LF, detectModulo);
}
else {
return true;
}
};
const ret = fn();
reset && scnr.resetPeek();
return ret;
}
function takeChar(scnr, fn) {
const ch = scnr.currentChar();
if (ch === EOF$1) {
return EOF$1;
}
if (fn(ch)) {
scnr.next();
return ch;
}
return null;
}
function takeIdentifierChar(scnr) {
const closure = (ch) => {
const cc = ch.charCodeAt(0);
return ((cc >= 97 && cc <= 122) || // a-z
(cc >= 65 && cc <= 90) || // A-Z
(cc >= 48 && cc <= 57) || // 0-9
cc === 95 || // _
cc === 36 // $
);
};
return takeChar(scnr, closure);
}
function takeDigit(scnr) {
const closure = (ch) => {
const cc = ch.charCodeAt(0);
return cc >= 48 && cc <= 57; // 0-9
};
return takeChar(scnr, closure);
}
function takeHexDigit(scnr) {
const closure = (ch) => {
const cc = ch.charCodeAt(0);
return ((cc >= 48 && cc <= 57) || // 0-9
(cc >= 65 && cc <= 70) || // A-F
(cc >= 97 && cc <= 102)); // a-f
};
return takeChar(scnr, closure);
}
function getDigits(scnr) {
let ch = '';
let num = '';
while ((ch = takeDigit(scnr))) {
num += ch;
}
return num;
}
function readModulo(scnr) {
skipSpaces(scnr);
const ch = scnr.currentChar();
if (ch !== "%" /* TokenChars.Modulo */) {
emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
}
scnr.next();
return "%" /* TokenChars.Modulo */;
}
function readText(scnr) {
let buf = '';
while (true) {
const ch = scnr.currentChar();
if (ch === "{" /* TokenChars.BraceLeft */ ||
ch === "}" /* TokenChars.BraceRight */ ||
ch === "@" /* TokenChars.LinkedAlias */ ||
ch === "|" /* TokenChars.Pipe */ ||
!ch) {
break;
}
else if (ch === "%" /* TokenChars.Modulo */) {
if (isTextStart(scnr)) {
buf += ch;
scnr.next();
}
else {
break;
}
}
else if (ch === CHAR_SP || ch === CHAR_LF) {
if (isTextStart(scnr)) {
buf += ch;
scnr.next();
}
else if (isPluralStart(scnr)) {
break;
}
else {
buf += ch;
scnr.next();
}
}
else {
buf += ch;
scnr.next();
}
}
return buf;
}
function readNamedIdentifier(scnr) {
skipSpaces(scnr);
let ch = '';
let name = '';
while ((ch = takeIdentifierChar(scnr))) {
name += ch;
}
if (scnr.currentChar() === EOF$1) {
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
}
return name;
}
function readListIdentifier(scnr) {
skipSpaces(scnr);
let value = '';
if (scnr.currentChar() === '-') {
scnr.next();
value += `-${getDigits(scnr)}`;
}
else {
value += getDigits(scnr);
}
if (scnr.currentChar() === EOF$1) {
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
}
return value;
}
function readLiteral(scnr) {
skipSpaces(scnr);
eat(scnr, `\'`);
let ch = '';
let literal = '';
const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
while ((ch = takeChar(scnr, fn))) {
if (ch === '\\') {
literal += readEscapeSequence(scnr);
}
else {
literal += ch;
}
}
const current = scnr.currentChar();
if (current === CHAR_LF || current === EOF$1) {
emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
// TODO: Is it correct really?
if (current === CHAR_LF) {
scnr.next();
eat(scnr, `\'`);
}
return literal;
}
eat(scnr, `\'`);
return literal;
}
function readEscapeSequence(scnr) {
const ch = scnr.currentChar();
switch (ch) {
case '\\':
case `\'`:
scnr.next();
return `\\${ch}`;
case 'u':
return readUnicodeEscapeSequence(scnr, ch, 4);
case 'U':
return readUnicodeEscapeSequence(scnr, ch, 6);
default:
emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
return '';
}
}
function readUnicodeEscapeSequence(scnr, unicode, digits) {
eat(scnr, unicode);
let sequence = '';
for (let i = 0; i < digits; i++) {
const ch = takeHexDigit(scnr);
if (!ch) {
emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
break;
}
sequence += ch;
}
return `\\${unicode}${sequence}`;
}
function readInvalidIdentifier(scnr) {
skipSpaces(scnr);
let ch = '';
let identifiers = '';
const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
ch !== "}" /* TokenChars.BraceRight */ &&
ch !== CHAR_SP &&
ch !== CHAR_LF;
while ((ch = takeChar(scnr, closure))) {
identifiers += ch;
}
return identifiers;
}
function readLinkedModifier(scnr) {
let ch = '';
let name = '';
while ((ch = takeIdentifierChar(scnr))) {
name += ch;
}
return name;
}
function readLinkedRefer(scnr) {
const fn = (detect = false, buf) => {
const ch = scnr.currentChar();
if (ch === "{" /* TokenChars.BraceLeft */ ||
ch === "%" /* TokenChars.Modulo */ ||
ch === "@" /* TokenChars.LinkedAlias */ ||
ch === "|" /* TokenChars.Pipe */ ||
!ch) {
return buf;
}
else if (ch === CHAR_SP) {
return buf;
}
else if (ch === CHAR_LF || ch === DOT) {
buf += ch;
scnr.next();
return fn(detect, buf);
}
else if (!isIdentifierStart(ch)) {
return buf;
}
else {
buf += ch;
scnr.next();
return fn(true, buf);
}
};
return fn(false, '');
}
function readPlural(scnr) {
skipSpaces(scnr);
const plural = eat(scnr, "|" /* TokenChars.Pipe */);
skipSpaces(scnr);
return plural;
}
// TODO: We need refactoring of token parsing ...
function readTokenInPlaceholder(scnr, context) {
let token = null;
const ch = scnr.currentChar();
switch (ch) {
case "{" /* TokenChars.BraceLeft */:
if (context.braceNest >= 1) {
emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
}
scnr.next();
token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
skipSpaces(scnr);
context.braceNest++;
return token;
case "}" /* TokenChars.BraceRight */:
if (context.braceNest > 0 &&
context.currentType === 2 /* TokenTypes.BraceLeft */) {
emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
}
scnr.next();
token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
context.braceNest--;
context.braceNest > 0 && skipSpaces(scnr);
if (context.inLinked && context.braceNest === 0) {
context.inLinked = false;
}
return token;
case "@" /* TokenChars.LinkedAlias */:
if (context.braceNest > 0) {
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
}
token = readTokenInLinked(scnr, context) || getEndToken(context);
context.braceNest = 0;
return token;
default:
let validNamedIdentifier = true;
let validListIdentifier = true;
let validLiteral = true;
if (isPluralStart(scnr)) {
if (context.braceNest > 0) {
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
}
token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
// reset
context.braceNest = 0;
context.inLinked = false;
return token;
}
if (context.braceNest > 0 &&
(context.currentType === 5 /* TokenTypes.Named */ ||
context.currentType === 6 /* TokenTypes.List */ ||
context.currentType === 7 /* TokenTypes.Literal */)) {
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
context.braceNest = 0;
return readToken(scnr, context);
}
if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
skipSpaces(scnr);
return token;
}
if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
skipSpaces(scnr);
return token;
}
if ((validLiteral = isLiteralStart(scnr, context))) {
token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
skipSpaces(scnr);
return token;
}
if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
// TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
skipSpaces(scnr);
return token;
}
break;
}
return token;
}
// TODO: We need refactoring of token parsing ...
function readTokenInLinked(scnr, context) {
const { currentType } = context;
let token = null;
const ch = scnr.currentChar();
if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
currentType === 9 /* TokenTypes.LinkedDot */ ||
currentType === 12 /* TokenTypes.LinkedModifier */ ||
currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
(ch === CHAR_LF || ch === CHAR_SP)) {
emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
}
switch (ch) {
case "@" /* TokenChars.LinkedAlias */:
scnr.next();
token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
context.inLinked = true;
return token;
case "." /* TokenChars.LinkedDot */:
skipSpaces(scnr);
scnr.next();
return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
case ":" /* TokenChars.LinkedDelimiter */:
skipSpaces(scnr);
scnr.next();
return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
default:
if (isPluralStart(scnr)) {
token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
// reset
context.braceNest = 0;
context.inLinked = false;
return token;
}
if (isLinkedDotStart(scnr, context) ||
isLinkedDelimiterStart(scnr, context)) {
skipSpaces(scnr);
return readTokenInLinked(scnr, context);
}
if (isLinkedModifierStart(scnr, context)) {
skipSpaces(scnr);
return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
}
if (isLinkedReferStart(scnr, context)) {
skipSpaces(scnr);
if (ch === "{" /* TokenChars.BraceLeft */) {
// scan the placeholder
return readTokenInPlaceholder(scnr, context) || token;
}
else {
return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
}
}
if (currentType === 8 /* TokenTypes.LinkedAlias */) {
emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
}
context.braceNest = 0;
context.inLinked = false;
return readToken(scnr, context);
}
}
// TODO: We need refactoring of token parsing ...
function readToken(scnr, context) {
let token = { type: 14 /* TokenTypes.EOF */ };
if (context.braceNest > 0) {
return readTokenInPlaceholder(scnr, context) || getEndToken(context);
}
if (context.inLinked) {
return readTokenInLinked(scnr, context) || getEndToken(context);
}
const ch = scnr.currentChar();
switch (ch) {
case "{" /* TokenChars.BraceLeft */:
return readTokenInPlaceholder(scnr, context) || getEndToken(context);
case "}" /* TokenChars.BraceRight */:
emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
scnr.next();
return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
case "@" /* TokenChars.LinkedAlias */:
return readTokenInLinked(scnr, context) || getEndToken(context);
default:
if (isPluralStart(scnr)) {
token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
// reset
context.braceNest = 0;
context.inLinked = false;
return token;
}
const { isModulo, hasSpace } = detectModuloStart(scnr);
if (isModulo) {
return hasSpace
? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
: getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
}
if (isTextStart(scnr)) {
return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
}
break;
}
return token;
}
function nextToken() {
const { currentType, offset, startLoc, endLoc } = _context;
_context.lastType = currentType;
_context.lastOffset = offset;
_context.lastStartLoc = startLoc;
_context.lastEndLoc = endLoc;
_context.offset = currentOffset();
_context.startLoc = currentPosition();
if (_scnr.currentChar() === EOF$1) {
return getToken(_context, 14 /* TokenTypes.EOF */);
}
return readToken(_scnr, _context);
}
return {
nextToken,
currentOffset,
currentPosition,
context
};
}
const ERROR_DOMAIN$2 = 'parser';
// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
function fromEscapeSequence(match, codePoint4, codePoint6) {
switch (match) {
case `\\\\`:
return `\\`;
case `\\\'`:
return `\'`;
default: {
const codePoint = parseInt(codePoint4 || codePoint6, 16);
if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
return String.fromCodePoint(codePoint);
}
// invalid ...
// Replace them with U+FFFD REPLACEMENT CHARACTER.
return '�';
}
}
}
function createParser(options = {}) {
const location = options.location !== false;
const { onError } = options;
function emitError(tokenzer, code, start, offset, ...args) {
const end = tokenzer.currentPosition();
end.offset += offset;
end.column += offset;
if (onError) {
const loc = location ? createLocation(start, end) : null;
const err = createCompileError(code, loc, {
domain: ERROR_DOMAIN$2,
args
});
onError(err);
}
}
function startNode(type, offset, loc) {
const node = { type };
if (location) {
node.start = offset;
node.end = offset;
node.loc = { start: loc, end: loc };
}
return node;
}
function endNode(node, offset, pos, type) {
if (type) {
node.type = type;
}
if (location) {
node.end = offset;
if (node.loc) {
node.loc.end = pos;
}
}
}
function parseText(tokenizer, value) {
const context = tokenizer.context();
const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
node.value = value;
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return node;
}
function parseList(tokenizer, index) {
const context = tokenizer.context();
const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
const node = startNode(5 /* NodeTypes.List */, offset, loc);
node.index = parseInt(index, 10);
tokenizer.nextToken(); // skip brach right
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return node;
}
function parseNamed(tokenizer, key) {
const context = tokenizer.context();
const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
const node = startNode(4 /* NodeTypes.Named */, offset, loc);
node.key = key;
tokenizer.nextToken(); // skip brach right
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return node;
}
function parseLiteral(tokenizer, value) {
const context = tokenizer.context();
const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
tokenizer.nextToken(); // skip brach right
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return node;
}
function parseLinkedModifier(tokenizer) {
const token = tokenizer.nextToken();
const context = tokenizer.context();
const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
// empty modifier
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
node.value = '';
endNode(node, offset, loc);
return {
nextConsumeToken: token,
node
};
}
// check token
if (token.value == null) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
node.value = token.value || '';
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return {
node
};
}
function parseLinkedKey(tokenizer, value) {
const context = tokenizer.context();
const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
node.value = value;
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
return node;
}
function parseLinked(tokenizer) {
const context = tokenizer.context();
const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
let token = tokenizer.nextToken();
if (token.type === 9 /* TokenTypes.LinkedDot */) {
const parsed = parseLinkedModifier(tokenizer);
linkedNode.modifier = parsed.node;
token = parsed.nextConsumeToken || tokenizer.nextToken();
}
// asset check token
if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
token = tokenizer.nextToken();
// skip brace left
if (token.type === 2 /* TokenTypes.BraceLeft */) {
token = tokenizer.nextToken();
}
switch (token.type) {
case 11 /* TokenTypes.LinkedKey */:
if (token.value == null) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
break;
case 5 /* TokenTypes.Named */:
if (token.value == null) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
linkedNode.key = parseNamed(tokenizer, token.value || '');
break;
case 6 /* TokenTypes.List */:
if (token.value == null) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
linkedNode.key = parseList(tokenizer, token.value || '');
break;
case 7 /* TokenTypes.Literal */:
if (token.value == null) {
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
}
linkedNode.key = parseLiteral(tokenizer, token.value || '');
break;
default:
// empty key
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
const nextContext = tokenizer.context();
const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
emptyLinkedKeyNode.value = '';
endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
linkedNode.key = emptyLinkedKeyNode;
endNode(linkedNode, nextContext.offset, nextContext.startLoc);
return {
nextConsumeToken: token,
node: linkedNode
};
}
endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
return {
node: linkedNode
};
}
function parseMessage(tokenizer) {
const context = tokenizer.context();
const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
? tokenizer.currentOffset()
: context.offset;
const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
? context.endLoc
: context.startLoc;
const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
node.items = [];