/*!

* vue-i18n v8.18.2

* (c) 2020 kazuya kawaguchi

* Released under the MIT License.

*/

(function (global, factory) {

typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

typeof define === 'function' && define.amd ? define(factory) :

(global.VueI18n = factory());

}(this, (function () { 'use strict';

/* */

/**

* constants

*/

var numberFormatKeys = [

'style',

'currency',

'currencyDisplay',

'useGrouping',

'minimumIntegerDigits',

'minimumFractionDigits',

'maximumFractionDigits',

'minimumSignificantDigits',

'maximumSignificantDigits',

'localeMatcher',

'formatMatcher',

'unit'

];

/**

* utilities

*/

function warn (msg, err) {

if (typeof console !== 'undefined') {

console.warn('[vue-i18n] ' + msg);

/* istanbul ignore if */

if (err) {

console.warn(err.stack);

}

}

}

function error (msg, err) {

if (typeof console !== 'undefined') {

console.error('[vue-i18n] ' + msg);

/* istanbul ignore if */

if (err) {

console.error(err.stack);

}

}

}

var isArray = Array.isArray;

function isObject (obj) {

return obj !== null && typeof obj === 'object'

}

function isBoolean (val) {

return typeof val === 'boolean'

}

function isString (val) {

return typeof val === 'string'

}

var toString = Object.prototype.toString;

var OBJECT_STRING = '[object Object]';

function isPlainObject (obj) {

return toString.call(obj) === OBJECT_STRING

}

function isNull (val) {

return val === null || val === undefined

}

function parseArgs () {

var args = [], len = arguments.length;

while ( len-- ) args[ len ] = arguments[ len ];

var locale = null;

var params = null;

if (args.length === 1) {

if (isObject(args[0]) || Array.isArray(args[0])) {

params = args[0];

} else if (typeof args[0] === 'string') {

locale = args[0];

}

} else if (args.length === 2) {

if (typeof args[0] === 'string') {

locale = args[0];

}

/* istanbul ignore if */

if (isObject(args[1]) || Array.isArray(args[1])) {

params = args[1];

}

}

return { locale: locale, params: params }

}

function looseClone (obj) {

return JSON.parse(JSON.stringify(obj))

}

function remove (arr, item) {

if (arr.length) {

var index = arr.indexOf(item);

if (index > -1) {

return arr.splice(index, 1)

}

}

}

function includes (arr, item) {

return !!~arr.indexOf(item)

}

var hasOwnProperty = Object.prototype.hasOwnProperty;

function hasOwn (obj, key) {

return hasOwnProperty.call(obj, key)

}

function merge (target) {

var arguments$1 = arguments;

var output = Object(target);

for (var i = 1; i < arguments.length; i++) {

var source = arguments$1[i];

if (source !== undefined && source !== null) {

var key = (void 0);

for (key in source) {

if (hasOwn(source, key)) {

if (isObject(source[key])) {

output[key] = merge(output[key], source[key]);

} else {

output[key] = source[key];

}

}

}

}

}

return output

}

function looseEqual (a, b) {

if (a === b) { return true }

var isObjectA = isObject(a);

var isObjectB = isObject(b);

if (isObjectA && isObjectB) {

try {

var isArrayA = Array.isArray(a);

var isArrayB = Array.isArray(b);

if (isArrayA && isArrayB) {

return a.length === b.length && a.every(function (e, i) {

return looseEqual(e, b[i])

})

} else if (!isArrayA && !isArrayB) {

var keysA = Object.keys(a);

var keysB = Object.keys(b);

return keysA.length === keysB.length && keysA.every(function (key) {

return looseEqual(a[key], b[key])

})

} else {

/* istanbul ignore next */

return false

}

} catch (e) {

/* istanbul ignore next */

return false

}

} else if (!isObjectA && !isObjectB) {

return String(a) === String(b)

} else {

return false

}

}

/* */

function extend (Vue) {

if (!Vue.prototype.hasOwnProperty('$i18n')) {

// $FlowFixMe

Object.defineProperty(Vue.prototype, '$i18n', {

get: function get () { return this._i18n }

});

}

Vue.prototype.$t = function (key) {

var values = [], len = arguments.length - 1;

while ( len-- > 0 ) values[ len ] = arguments[ len + 1 ];

var i18n = this.$i18n;

return i18n._t.apply(i18n, [ key, i18n.locale, i18n._getMessages(), this ].concat( values ))

};

Vue.prototype.$tc = function (key, choice) {

var values = [], len = arguments.length - 2;

while ( len-- > 0 ) values[ len ] = arguments[ len + 2 ];

var i18n = this.$i18n;

return i18n._tc.apply(i18n, [ key, i18n.locale, i18n._getMessages(), this, choice ].concat( values ))

};

Vue.prototype.$te = function (key, locale) {

var i18n = this.$i18n;

return i18n._te(key, i18n.locale, i18n._getMessages(), locale)

};

Vue.prototype.$d = function (value) {

var ref;

var args = [], len = arguments.length - 1;

while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];

return (ref = this.$i18n).d.apply(ref, [ value ].concat( args ))

};

Vue.prototype.$n = function (value) {

var ref;

var args = [], len = arguments.length - 1;

while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];

return (ref = this.$i18n).n.apply(ref, [ value ].concat( args ))

};

}

/* */

var mixin = {

beforeCreate: function beforeCreate () {

var options = this.$options;

options.i18n = options.i18n || (options.__i18n ? {} : null);

if (options.i18n) {

if (options.i18n instanceof VueI18n) {

// init locale messages via custom blocks

if (options.__i18n) {

try {

var localeMessages = {};

options.__i18n.forEach(function (resource) {

localeMessages = merge(localeMessages, JSON.parse(resource));

});

Object.keys(localeMessages).forEach(function (locale) {

options.i18n.mergeLocaleMessage(locale, localeMessages[locale]);

});

} catch (e) {

{

error("Cannot parse locale messages via custom blocks.", e);

}

}

}

this._i18n = options.i18n;

this._i18nWatcher = this._i18n.watchI18nData();

} else if (isPlainObject(options.i18n)) {

var rootI18n = this.$root && this.$root.$i18n && this.$root.$i18n instanceof VueI18n

? this.$root.$i18n

: null;

// component local i18n

if (rootI18n) {

options.i18n.root = this.$root;

options.i18n.formatter = rootI18n.formatter;

options.i18n.fallbackLocale = rootI18n.fallbackLocale;

options.i18n.formatFallbackMessages = rootI18n.formatFallbackMessages;

options.i18n.silentTranslationWarn = rootI18n.silentTranslationWarn;

options.i18n.silentFallbackWarn = rootI18n.silentFallbackWarn;

options.i18n.pluralizationRules = rootI18n.pluralizationRules;

options.i18n.preserveDirectiveContent = rootI18n.preserveDirectiveContent;

}

// init locale messages via custom blocks

if (options.__i18n) {

try {

var localeMessages$1 = {};

options.__i18n.forEach(function (resource) {

localeMessages$1 = merge(localeMessages$1, JSON.parse(resource));

});

options.i18n.messages = localeMessages$1;

} catch (e) {

{

warn("Cannot parse locale messages via custom blocks.", e);

}

}

}

var ref = options.i18n;

var sharedMessages = ref.sharedMessages;

if (sharedMessages && isPlainObject(sharedMessages)) {

options.i18n.messages = merge(options.i18n.messages, sharedMessages);

}

this._i18n = new VueI18n(options.i18n);

this._i18nWatcher = this._i18n.watchI18nData();

if (options.i18n.sync === undefined || !!options.i18n.sync) {

this._localeWatcher = this.$i18n.watchLocale();

}

if (rootI18n) {

rootI18n.onComponentInstanceCreated(this._i18n);

}

} else {

{

warn("Cannot be interpreted 'i18n' option.");

}

}

} else if (this.$root && this.$root.$i18n && this.$root.$i18n instanceof VueI18n) {

// root i18n

this._i18n = this.$root.$i18n;

} else if (options.parent && options.parent.$i18n && options.parent.$i18n instanceof VueI18n) {

// parent i18n

this._i18n = options.parent.$i18n;

}

},

beforeMount: function beforeMount () {

var options = this.$options;

options.i18n = options.i18n || (options.__i18n ? {} : null);

if (options.i18n) {

if (options.i18n instanceof VueI18n) {

// init locale messages via custom blocks

this._i18n.subscribeDataChanging(this);

this._subscribing = true;

} else if (isPlainObject(options.i18n)) {

this._i18n.subscribeDataChanging(this);

this._subscribing = true;

} else {

{

warn("Cannot be interpreted 'i18n' option.");

}

}

} else if (this.$root && this.$root.$i18n && this.$root.$i18n instanceof VueI18n) {

this._i18n.subscribeDataChanging(this);

this._subscribing = true;

} else if (options.parent && options.parent.$i18n && options.parent.$i18n instanceof VueI18n) {

this._i18n.subscribeDataChanging(this);

this._subscribing = true;

}

},

beforeDestroy: function beforeDestroy () {

if (!this._i18n) { return }

var self = this;

this.$nextTick(function () {

if (self._subscribing) {

self._i18n.unsubscribeDataChanging(self);

delete self._subscribing;

}

if (self._i18nWatcher) {

self._i18nWatcher();

self._i18n.destroyVM();

delete self._i18nWatcher;

}

if (self._localeWatcher) {

self._localeWatcher();

delete self._localeWatcher;

}

});

}

};

/* */

var interpolationComponent = {

name: 'i18n',

functional: true,

props: {

tag: {

type: [String, Boolean],

default: 'span'

},

path: {

type: String,

required: true

},

locale: {

type: String

},

places: {

type: [Array, Object]

}

},

render: function render (h, ref) {

var data = ref.data;

var parent = ref.parent;

var props = ref.props;

var slots = ref.slots;

var $i18n = parent.$i18n;

if (!$i18n) {

{

warn('Cannot find VueI18n instance!');

}

return

}

var path = props.path;

var locale = props.locale;

var places = props.places;

var params = slots();

var children = $i18n.i(

path,

locale,

onlyHasDefaultPlace(params) || places

? useLegacyPlaces(params.default, places)

: params

);

var tag = (!!props.tag && props.tag !== true) || props.tag === false ? props.tag : 'span';

return tag ? h(tag, data, children) : children

}

};

function onlyHasDefaultPlace (params) {

var prop;

for (prop in params) {

if (prop !== 'default') { return false }

}

return Boolean(prop)

}

function useLegacyPlaces (children, places) {

var params = places ? createParamsFromPlaces(places) : {};

if (!children) { return params }

// Filter empty text nodes

children = children.filter(function (child) {

return child.tag || child.text.trim() !== ''

});

var everyPlace = children.every(vnodeHasPlaceAttribute);

if (everyPlace) {

warn('`place` attribute is deprecated in next major version. Please switch to Vue slots.');

}

return children.reduce(

everyPlace ? assignChildPlace : assignChildIndex,

params

)

}

function createParamsFromPlaces (places) {

{

warn('`places` prop is deprecated in next major version. Please switch to Vue slots.');

}

return Array.isArray(places)

? places.reduce(assignChildIndex, {})

: Object.assign({}, places)

}

function assignChildPlace (params, child) {

if (child.data && child.data.attrs && child.data.attrs.place) {

params[child.data.attrs.place] = child;

}

return params

}

function assignChildIndex (params, child, index) {

params[index] = child;

return params

}

function vnodeHasPlaceAttribute (vnode) {

return Boolean(vnode.data && vnode.data.attrs && vnode.data.attrs.place)

}

/* */

var numberComponent = {

name: 'i18n-n',

functional: true,

props: {

tag: {

type: [String, Boolean],

default: 'span'

},

value: {

type: Number,

required: true

},

format: {

type: [String, Object]

},

locale: {

type: String

}

},

render: function render (h, ref) {

var props = ref.props;

var parent = ref.parent;

var data = ref.data;

var i18n = parent.$i18n;

if (!i18n) {

{

warn('Cannot find VueI18n instance!');

}

return null

}

var key = null;

var options = null;

if (isString(props.format)) {

key = props.format;

} else if (isObject(props.format)) {

if (props.format.key) {

key = props.format.key;

}

// Filter out number format options only

options = Object.keys(props.format).reduce(function (acc, prop) {

var obj;

if (includes(numberFormatKeys, prop)) {

return Object.assign({}, acc, ( obj = {}, obj[prop] = props.format[prop], obj ))

}

return acc

}, null);

}

var locale = props.locale || i18n.locale;

var parts = i18n._ntp(props.value, locale, key, options);

var values = parts.map(function (part, index) {

var obj;

var slot = data.scopedSlots && data.scopedSlots[part.type];

return slot ? slot(( obj = {}, obj[part.type] = part.value, obj.index = index, obj.parts = parts, obj )) : part.value

});

var tag = (!!props.tag && props.tag !== true) || props.tag === false ? props.tag : 'span';

return tag

? h(tag, {

attrs: data.attrs,

'class': data['class'],

staticClass: data.staticClass

}, values)

: values

}

};

/* */

function bind (el, binding, vnode) {

if (!assert(el, vnode)) { return }

t(el, binding, vnode);

}

function update (el, binding, vnode, oldVNode) {

if (!assert(el, vnode)) { return }

var i18n = vnode.context.$i18n;

if (localeEqual(el, vnode) &&

(looseEqual(binding.value, binding.oldValue) &&

looseEqual(el._localeMessage, i18n.getLocaleMessage(i18n.locale)))) { return }

t(el, binding, vnode);

}

function unbind (el, binding, vnode, oldVNode) {

var vm = vnode.context;

if (!vm) {

warn('Vue instance does not exists in VNode context');

return

}

var i18n = vnode.context.$i18n || {};

if (!binding.modifiers.preserve && !i18n.preserveDirectiveContent) {

el.textContent = '';

}

el._vt = undefined;

delete el['_vt'];

el._locale = undefined;

delete el['_locale'];

el._localeMessage = undefined;

delete el['_localeMessage'];

}

function assert (el, vnode) {

var vm = vnode.context;

if (!vm) {

warn('Vue instance does not exists in VNode context');

return false

}

if (!vm.$i18n) {

warn('VueI18n instance does not exists in Vue instance');

return false

}

return true

}

function localeEqual (el, vnode) {

var vm = vnode.context;

return el._locale === vm.$i18n.locale

}

function t (el, binding, vnode) {

var ref$1, ref$2;

var value = binding.value;

var ref = parseValue(value);

var path = ref.path;

var locale = ref.locale;

var args = ref.args;

var choice = ref.choice;

if (!path && !locale && !args) {

warn('value type not supported');

return

}

if (!path) {

warn('`path` is required in v-t directive');

return

}

var vm = vnode.context;

if (choice != null) {

el._vt = el.textContent = (ref$1 = vm.$i18n).tc.apply(ref$1, [ path, choice ].concat( makeParams(locale, args) ));

} else {

el._vt = el.textContent = (ref$2 = vm.$i18n).t.apply(ref$2, [ path ].concat( makeParams(locale, args) ));

}

el._locale = vm.$i18n.locale;

el._localeMessage = vm.$i18n.getLocaleMessage(vm.$i18n.locale);

}

function parseValue (value) {

var path;

var locale;

var args;

var choice;

if (isString(value)) {

path = value;

} else if (isPlainObject(value)) {

path = value.path;

locale = value.locale;

args = value.args;

choice = value.choice;

}

return { path: path, locale: locale, args: args, choice: choice }

}

function makeParams (locale, args) {

var params = [];

locale && params.push(locale);

if (args && (Array.isArray(args) || isPlainObject(args))) {

params.push(args);

}

return params

}

var Vue;

function install (_Vue) {

/* istanbul ignore if */

if (install.installed && _Vue === Vue) {

warn('already installed.');

return

}

install.installed = true;

Vue = _Vue;

var version = (Vue.version && Number(Vue.version.split('.')[0])) || -1;

/* istanbul ignore if */

if (version < 2) {

warn(("vue-i18n (" + (install.version) + ") need to use Vue 2.0 or later (Vue: " + (Vue.version) + ")."));

return

}

extend(Vue);

Vue.mixin(mixin);

Vue.directive('t', { bind: bind, update: update, unbind: unbind });

Vue.component(interpolationComponent.name, interpolationComponent);

Vue.component(numberComponent.name, numberComponent);

// use simple mergeStrategies to prevent i18n instance lose '__proto__'

var strats = Vue.config.optionMergeStrategies;

strats.i18n = function (parentVal, childVal) {

return childVal === undefined

? parentVal

: childVal

};

}

/* */

var BaseFormatter = function BaseFormatter () {

this._caches = Object.create(null);

};

BaseFormatter.prototype.interpolate = function interpolate (message, values) {

if (!values) {

return [message]

}

var tokens = this._caches[message];

if (!tokens) {

tokens = parse(message);

this._caches[message] = tokens;

}

return compile(tokens, values)

};

var RE_TOKEN_LIST_VALUE = /^(?:\d)+/;

var RE_TOKEN_NAMED_VALUE = /^(?:\w)+/;

function parse (format) {

var tokens = [];

var position = 0;

var text = '';

while (position < format.length) {

var char = format[position++];

if (char === '{') {

if (text) {

tokens.push({ type: 'text', value: text });

}

text = '';

var sub = '';

char = format[position++];

while (char !== undefined && char !== '}') {

sub += char;

char = format[position++];

}

var isClosed = char === '}';

var type = RE_TOKEN_LIST_VALUE.test(sub)

? 'list'

: isClosed && RE_TOKEN_NAMED_VALUE.test(sub)

? 'named'

: 'unknown';

tokens.push({ value: sub, type: type });

} else if (char === '%') {

// when found rails i18n syntax, skip text capture

if (format[(position)] !== '{') {

text += char;

}

} else {

text += char;

}

}

text && tokens.push({ type: 'text', value: text });

return tokens

}

function compile (tokens, values) {

var compiled = [];

var index = 0;

var mode = Array.isArray(values)

? 'list'

: isObject(values)

? 'named'

: 'unknown';

if (mode === 'unknown') { return compiled }

while (index < tokens.length) {

var token = tokens[index];

switch (token.type) {

case 'text':

compiled.push(token.value);

break

case 'list':

compiled.push(values[parseInt(token.value, 10)]);

break

case 'named':

if (mode === 'named') {

compiled.push((values)[token.value]);

} else {

{

warn(("Type of token '" + (token.type) + "' and format of value '" + mode + "' don't match!"));

}

}

break

case 'unknown':

{

warn("Detect 'unknown' type of token!");

}

break

}

index++;

}

return compiled

}

/* */

/**

* Path parser

* - Inspired:

* Vue.js Path parser

*/

// actions

var APPEND = 0;

var PUSH = 1;

var INC_SUB_PATH_DEPTH = 2;

var PUSH_SUB_PATH = 3;

// states

var BEFORE_PATH = 0;

var IN_PATH = 1;

var BEFORE_IDENT = 2;

var IN_IDENT = 3;

var IN_SUB_PATH = 4;

var IN_SINGLE_QUOTE = 5;

var IN_DOUBLE_QUOTE = 6;

var AFTER_PATH = 7;

var ERROR = 8;

var pathStateMachine = [];

pathStateMachine[BEFORE_PATH] = {

'ws': [BEFORE_PATH],

'ident': [IN_IDENT, APPEND],

'[': [IN_SUB_PATH],

'eof': [AFTER_PATH]

};

pathStateMachine[IN_PATH] = {

'ws': [IN_PATH],

'.': [BEFORE_IDENT],

'[': [IN_SUB_PATH],

'eof': [AFTER_PATH]

};

pathStateMachine[BEFORE_IDENT] = {

'ws': [BEFORE_IDENT],

'ident': [IN_IDENT, APPEND],

'0': [IN_IDENT, APPEND],

'number': [IN_IDENT, APPEND]

};

pathStateMachine[IN_IDENT] = {

'ident': [IN_IDENT, APPEND],

'0': [IN_IDENT, APPEND],

'number': [IN_IDENT, APPEND],

'ws': [IN_PATH, PUSH],

'.': [BEFORE_IDENT, PUSH],

'[': [IN_SUB_PATH, PUSH],

'eof': [AFTER_PATH, PUSH]

};

pathStateMachine[IN_SUB_PATH] = {

"'": [IN_SINGLE_QUOTE, APPEND],

'"': [IN_DOUBLE_QUOTE, APPEND],

'[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],

']': [IN_PATH, PUSH_SUB_PATH],

'eof': ERROR,

'else': [IN_SUB_PATH, APPEND]

};

pathStateMachine[IN_SINGLE_QUOTE] = {

"'": [IN_SUB_PATH, APPEND],

'eof': ERROR,

'else': [IN_SINGLE_QUOTE, APPEND]

};

pathStateMachine[IN_DOUBLE_QUOTE] = {

'"': [IN_SUB_PATH, APPEND],

'eof': ERROR,

'else': [IN_DOUBLE_QUOTE, APPEND]

};

/**

* Check if an expression is a literal value.

*/

var literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;

function isLiteral (exp) {

return literalValueRE.test(exp)

}

/**

* Strip quotes from a string

*/

function stripQuotes (str) {

var a = str.charCodeAt(0);

var b = str.charCodeAt(str.length - 1);

return a === b && (a === 0x22 || a === 0x27)

? str.slice(1, -1)

: str

}

/**

* Determine the type of a character in a keypath.

*/

function getPathCharType (ch) {

if (ch === undefined || ch === null) { return 'eof' }

var code = ch.charCodeAt(0);

switch (code) {

case 0x5B: // [

case 0x5D: // ]

case 0x2E: // .

case 0x22: // "

case 0x27: // '

return ch

case 0x5F: // _

case 0x24: // $

case 0x2D: // -

return 'ident'

case 0x09: // Tab

case 0x0A: // Newline

case 0x0D: // Return

case 0xA0: // No-break space

case 0xFEFF: // Byte Order Mark

case 0x2028: // Line Separator

case 0x2029: // Paragraph Separator

return 'ws'

}

return 'ident'

}

/**

* Format a subPath, return its plain form if it is

* a literal string or number. Otherwise prepend the

* dynamic indicator (*).

*/

function formatSubPath (path) {

var trimmed = path.trim();

// invalid leading 0

if (path.charAt(0) === '0' && isNaN(path)) { return false }

return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed

}

/**

* Parse a string path into an array of segments

*/

function parse$1 (path) {

var keys = [];

var index = -1;

var mode = BEFORE_PATH;

var subPathDepth = 0;

var c;

var key;

var newChar;

var type;

var transition;

var action;

var typeMap;

var actions = [];

actions[PUSH] = function () {

if (key !== undefined) {

keys.push(key);

key = undefined;

}

};

actions[APPEND] = function () {

if (key === undefined) {

key = newChar;

} else {

key += newChar;

}

};

actions[INC_SUB_PATH_DEPTH] = function () {

actions[APPEND]();

subPathDepth++;

};

actions[PUSH_SUB_PATH] = function () {

if (subPathDepth > 0) {

subPathDepth--;

mode = IN_SUB_PATH;